Licence professionnelle QCI Universit Robert Schuman e

Programmation oriente objet e 2008/09

Programmation Objet - C#
c Beno Caldairou, 2008 t

1
1.1

Introduction
Quest-ce que la programmation oriente objet ? e

Contrairement ` la programmation dite imprative, qui nest quun simple a e traitement sur des donnes, la programmation oriente objet (ou POO) est une e e technique visant ` faire interagir des objets entre eux, permettant une meilleure a modularit et une plus grande souplesse de la programmation. e Ainsi, un objet va tre constitu par lassociation dune quantit dinformae e e tion organise en champs (nom, prnom, age, notes pour un tudiant ; marque, e e e mod`le, cylindre, vitesse pour une voiture) et dun ensemble de mthodes (plus e e e ou moins quivalentes ` des fonctions) permettant dinteragir avec lui (calculer e a la moyenne dun tudiant ou acclrer pour une voiture). e ee Cette technique de programmation a principalement deux objectifs : Faciliter lcriture des applications par une structuration en terme dobe jets. Favoriser la rutilisation de code, en composant des programmes ` partir e a dobjets existants (par exemple, la biblioth`que standart de C++, de Java, e . . . ). Deux notions essentielles sont caractristiques de la POO : e La notion de classe : schmatiquement, une classe reprsente le type dun e e objet, tout comme int reprsente un rel. Elle peut tre vu comme une e e e sorte de super-structure. La notion de mthode : schmatiquement, une mthode est une fonction e e e appartenant ` une classe et permettant dagir sur et avec lobjet. a

1.2

Concepts clefs de la programmation oriente objet e

La POO a introduit des concepts permettant une bien meilleure souplesse de programmation ainsi quune plus grande scurit. e e Dans un soucis de rutilisation du code, une classe doit tre susamment e e bien conu pour quun programmeur nait pas ` sinquiter de ltat interne c a e e dun objet, mais se contente de savoir de quelle mani`re il interagit avec son e environnement. Cette volont de masquer la reprsentation de lobjet sappelle e e lencapsulation et am`ne aussi une scurit du code dans la mesure ou ltat e e e e de lobjet ne peut tre chang que de mani`re explicite. Cel` permet aussi de e e e a modier la reprsentation dune classe sans forcment modier les interactions e e et donc les programmes dpendants de ces classes. e

Toujours dans un soucis decacit et de modularit, la POO a introduit la e e notion dhritage entre les classes. Tr`s schmatiquement, on peut dnir grce e e e e a ` lhritage une classe dite m`re ` partir de laquelle on va dnir plusieurs a e e a e classes dites lles ayant en commun les caractristiques de la classe m`re. e e Cela permet une conomie du code et favorise sa rutilisation. e e La POO introduit enn des concepts plus avancs tels que le polymorphisme e et la gnricit qui seront abords ultrieurement. e e e e e

1.3
1.3.1

Principales notions de base

Classe

Schmatiquement, une classe est la description dune collection objets e homog`nes. La notion de classe peut tre utilis de plusieurs faons : e e e c pour dnir un ensemble de sous-programmes (classes utilitaires) ; e pour dnir un nouveau type dobjet, par exemple un objet de type voie ture, de type personne ou de type l`ve. ee Une classe doit ncessairement comporter les lments suivants : e ee les champs : ce sont les variables permettant, en gnral, de dnir e e e ltat de lobjet. e un ou plusieurs constructeurs : ce sont des fonctions indiquant de quelle faon lobjet doit tre dclar et initialis. c e e e e les mthodes : ce sont les fonctions permettant dagir sur les objets dune e classe. Selon leur dnition, elle peuvent sappliquer sur un objet particue lier, ou sur lensemble des instances dune classe. 1.3.2 Objet

Nous avons vu prcdemment quun objet est une instance de classe. Par e e analogie, on peut aussi considrer une classe comme le type dune variable et e lobjet comme la valeur de cette mme variable. e A sa cration, un objet est contruit et initialis grce a un constructeur et il e e a ` va rester en mmoire jusqu` la n de la fonction qui lemploie, de la mme faon e a e c quune variable. Au moment de sa destruction, un fonction spciale, appelle un e e destructeur, est appele, qui est ici masqu par le language C# (ainsi quen e e Java) contrairement ` dautre languages orients objets comme le C++ qui a e ncessitent une dnition formelle du destructeur au mme titre que la dnition e e e e dun constructeur.

Notion de classe

Dans la suite de ce cours, nous allons considrer ` titre illustratif une classe e a Personne dont on veut stocker les nom, prnom, ge et numro de tlphone e a e ee tout tant capable de modier et dacher ces informations. e

2.1

Gnralits e e e

De mani`re formelle, une classe dclare un ensemble dinjonctions communes e e ` une famille dobjets (des attributs pour ltat de lobjet et des mthodes a e e

reprsentant le comportement de lobjet). Un bon exemple de classe existante e est la classe string ou encore la classe list. En C#, une classe sera toujours dnie de la mani`re suivante : e e public class Personne { //Dclaration des champs e ... //Dclaration des contructeurs e ... //Dclaration des mthodes e e ... }

2.2

Champs

Comme dit plus haut, les champs reprsentent les variables traduisant e ltat de lobjet (comme avec les champs des structures). Ces variables peuvent e tre de toutes natures : des entiers, des cha e nes de caract`res, des listes, dautres e objets, etc. . . Par convention, leur nom commencent toujours par une minuscule. Dans le cas de notre classe personne, nous allons dclarer les champs suie vants : nom, prnom, age et numro de tlphone : e e ee public class { private private private private } Personne string nom; string prenom; int age; int telephone;

Le mot clef public devant le mot clef class indique que la classe Personne est accessible depuis nimporte quelle partie du programme. Elle aura aussi son importance au moment ou nous aborderons lhritage. e Le mot clef private devant les champs indique ici que ces variables ne sont pas accessibles en dehors de la classe personne. Un programmeur utilisant la classe personne ne pourra donc pas utiliser ces variables directement dans dautres fonction sauf si private est remplac par le mot clef public. Si aucun mot clef e nest prcis, private sera ajout par dfaut ` la compilation. e e e e a

2.3

Constructeurs

Un contructeur est une fonction appelle au moment de la cration dun objet e e a ` partir dune classe. Il permet dinitialiser correctement cet objet, ventuellement e a ` partir de param`tres. e Plusieurs contructeurs peuvent tre dnis. e e public class Personne { 3

//Champs private string nom; private string prenom; private int age; private int telephone; //Constructeurs public personne(){} //Constructeur par dfaut e public personne(string nom, string prenom, int age, int telephone) { this.nom = nom; this.prenom = prenom; this.age = age; this.telephone = telephone; } public personne(personne p) { this.nom = p.nom; this.prenom = p.prenom; this.age = p.age; this.telephone = p.telephone; } } Le mot clef this est une rfrence sur linstance courante. Elle permet daccder ee e ` lobjet appelant depuis la mthode et aussi dviter les confusions lorsque deux a e e variables ont le mme nom. Par exemple, dans le deuxi`me constructeur, le fait e e dcrire this.nom permet de ne pas confondre le champ nom de lobjet personne e avec la variable nom passe en param`tre pour linitialisation. Le troisi`me e e e constructeur est un constructeur particulier dans le sens ou il cre un objet pere sonne en copiant les informations contenues dans un autre objet personne. On appelle cela un constructeur par copie. Le premier constructeur est aussi un peu particulier vu quil ne prend aucun param`tre en entre. Il est cependant essentiel de le dnir an dviter les e e e e surprises au moment de lexcution et il est aussi utile si on dnit une classee e lle comme nous le verrons ultrieurement. e

2.4

Proprits e e

Nous avons vu quen rendant les champs privs, un programmeur utilisateur e de la classe personne ne pourra pas lire, ni crire de valeur dans ces variables. Le e comportement de lobjet devient alors quivalent ` celui dune boite noire dont e a on ne peut pas connaitre ltat interne. Cependant, il se peut que le programe meur ait besoin de connaitre ces informations et ait aussi besoin de les mettre ` a jour. Pour viter de violer le principe dencapsulation, nous allons donc dnir e e des moyens daccder ` ces variables ` travers des proprits. Une proprit e a a ee ee permet de dnir des acc`s en consultation (get ) et en modication (set ). Un e e 4

acc`s en consultation ou en modication est possible uniquement si le get ou set e correspondant est dnie. e La syntaxe dune proprit se dnit de la mani`re suivante : ee e e public int Age { get { return this.age; } set { this.age = value; } } Le mot clef public indique bien que la proprit peut tre utilise dans nimee e e porte quelle partie du code et que le mot clef int indique bien que get renvoie une valeur de type int et que set attend une valeur de type int. Un autre exemple avec le champ nom : public string Nom { get { return this.nom; } set { if (value == null || value.Trim().Length == 0) { Console.WriteLine("Nom Invalide"); nom = null; } else { nom = value; } } } Ici, pour viter quune erreur ne survienne au moment de lexecution, il vaut e mieux vrier que la param`tre pass ` set soit eectivement initialis et quil e e ea e ait une longueur suprieure ` 0. e a

2.5

Mthodes e

Les mthodes sont des sous-porgrammes propres ` agir sur les objets e a dune classe. Elles sont assimilables ` des fonctions sauf quelles sont gnralement a e e 5

appels par des objets et agissent potentiellement sur eux. e 2.5.1 Mthodes dinstance e

Ces mthodes dcrivent des oprations eectues sur une instance partie e e e culi`re de la classe (cest-`-dire sur un seul objet). e a Un bon exemple est la mthode de la classe string (cha e nes de caract`res) e ToLower() qui permet de passer toutes les lettres dune cha en minuscules ne de la faon suivante : c string s = new string("Une souris Verte qui Courait dans lherBe"); s = s.ToLower(); Cette opration va transformer le contenu de s en : une souris verte qui e courait dans le pr. e 2.5.2 Champs, mthodes et proprits de classe e e e

Les champs de classe sont des champs que les objets dune mme classe vont e partager. De mme, les mthodes et les proprits de classe sont des mthodes e e ee e qui vont aecter lensemble des objets dune classe. Reprenons notre classe Personne. Nous aimerions disposer dun compteur permettant de connaitre en permanence combien dinstances de Personne il existe. Il sut alors de dclarer un champ dinstance de la mani`re suivante : e e private static int nbPersonne; Remarquez au passage le mot clef static qui indique que ce champ est un champ de classe. Il faut alors rednir les constructeur de la mani`re suivante : e e public class Personne { //Constructeurs public personne(){nbPersonne++;} //Constructeur par dfault e public personne(string nom, string prenom, int age, int telephone) { this.nom = nom; this.prenom = prenom; this.age = age; this.telephone = telephone; nbPersonne++; } public personne(personne p) { this.nom = p.nom; this.prenom = p.prenom; this.age = p.age; 6

this.telephone = p.telephone; nbPersonne++; } } De mani`re ` accder ` la variable nbPersonne, on dnit une proprit de e a e a e ee classe permettant un acc`s en lecture seule. En eet, il est prfrable de ne pas e ee laisser de possibilit au programmeur de modier cette variable autrement quen e crant direntes personnes. e e public static long NbPersonne { get { return nbPersonne; } } Pour les mthodes, cela fonctionne de la mme faon. Il sut dajouter le e e c mot clef static pour la dclarer comme tant de classe. Elle sappliquera alors e e sur lensemble des instances dune classe. 2.5.3 Surcharge de mthodes e

Nous avons vu prcedemment que nous pouvions donner plusieurs formes e de constructeur qui ayant pour objectifs dinitialiser un objet, mais avec des comportements dirents. e Le C# autorise le mme genre de comportement pour les mthodes. On e e peut appeller plusieurs mthodes par le mme nom (la logique veut que ces e e mthodes aient un comportement similaire) tout en leur donnant des param`tres e e dirents. On appelle cel` la surcharge de mthode. Cela sapplique aussi bien e a e aux mthodes dinstance quaux mthodes de classes. Un exemple concret se e e trouve dans la classe string avec lensemble des mthodes IndexOf(. . . ), pere mettant de chercher lindex (ou la position dans la cha ne) dun caract`re ou e dune sous-cha de caract`res. ne e //mthodes e public int public int public int public int surcharges e IndexOf(char value)... IndexOf(string value)... IndexOf(char value, int startIndex)... IndexOf(string value, int startIndex)...

La dirence entre ces mthodes se fait par le nombre de param`tres, leur e e e type et leur ordre.

2.6

Oprateurs e

Les oprateurs dnis pour une classe sont identis par des symboles tels e e e que =, +, -, ==, =, . . . Cependant, dun point de vue logique, ces oprateurs e ne sont pas dirents des fonctions. Ils doivent tre dnis de la mme mani`re, e e e e e cependant leur utilisation est plus intuitive. Voici un exemple doprateur permettant de savoir si deux personnes sont e identiques :

public static bool operator ==(Personne a, Personne b) { if(a.nom == b.nom && a.prenom == b.prenom && a.age == b.age && a.telephone == b.telephone) return 1; else return 0; } Remarquez lutilisation du mot clef static car il sagit dune mthode de e classe, tant donn que cet oprateur doit pouvoir sappliquer indiremment ` e e e e a nimporte quelles instances de la classe. Dans le programme principale, il sera utilis de la faon suivante : e c //On suppose que deux instances de Personnes p1 et p2 //ont dj` t initialise e a e e e if(p1 == p2) Console.WriteLine("p1 et p2 sont la m^me personne"); e else Console.WriteLine("p1 et p2 sont deux personnes diffrentes"); e

2.7

Notions de mutabilit e

Ce terme dsigne le fait quune instance de classe puisse tre modie ou e e e pas au cours de lexcution du programme (cest-`-dire modier ses champs). e a Par exemple dans le cas de notre classe Personne, le fait dautoriser lacc`s en e criture sur les champs rend la classe mutable. Il surait de supprimer cette e possibilit pour rendre cette classe non mutable. e

2.8

En exemple complet : la classe Personne

Voici limplmentation compl`te de la classe personne dnie tout au long e e e de cette section : public class Personne { //Champ et proprit de classe e e private static int nbPersonne; public static long NbPersonne { get { return nbPersonne; } } //Champs dinstance private string nom; private string prenom; private int age; private int telephone; //Constructeurs 8

public personne(){nbPersonne++;} //Constructeur par dfault e public personne(string nom, string prenom, int age, int telephone) { this.nom = nom; this.prenom = prenom; this.age = age; this.telephone = telephone; nbPersonne++; } public personne(personne p) { this.nom = p.nom; this.prenom = p.prenom; this.age = p.age; this.telephone = p.telephone; nbPersonne++; } //Proprit e e public string Nom { get { return this.nom; } set { if (value == null || value.Trim().Length == 0) { Console.WriteLine("Nom Invalide"); nom = null; } else { nom = value; } } } public string Prenom { get { return this.prenom; } set 9

{ if (value == null || value.Trim().Length == 0) { Console.WriteLine("Prnom Invalide"); e prenom = null; } else { prenom = value; } } } public int Age { get { return this.age; } set { this.age = value; } } public int Telephone { get { return this.telephone; } set { this.telephone = value; } }

//Oprateur e public static bool operator ==(Personne a, Personne b) { if(a.nom == b.nom && a.prenom == b.prenom && a.age == b.age && a.telephone == b.tele return 1; else return 0; } //Mthode e public string Identifie() 10

string s = "p=(" + this.prenom + "," + this.nom + "," + p.age + "," + p.telephone ") return s; } }

Notion dobjet

Par dnition, un objet est une instance dune classe. Tandis quune classe est e une reprsentation abstraite, lobjet reprsente quelque chose de tr`s concret vu e e e quil est stock en mmoire et quon peut agir sur lui par le biais des mthodes, e e e proprits et oprateurs. Un exemple pour illustrer ce propos : la plan dune ee e maison reprsente la classe et on peut contruire une multitude de maison sur ce e mod`le. e

3.1

Cration e

La cration dun objet obit ` des r`gles logiques et syntaxiques particuli`re. e e a e e En eet, si vous vous contentez de dclarer : e Personne p1; rien ne va se passer. Il faut comprendre que vous vous tes content de dclarer e e e une variable de type Personne. Mais cette variable nest rien de plus quune coquille vide. Les champs ne sont pas remplit et il est impossible dutiliser les mthodes pour la simple et bonne raison que la Personne p1 nexiste pas encore. e Pour pouvoir utiliser cette variable ` notre convenance, il va falloir contruire a la Personne. Pour ce faire, nous utilisons la syntaxe suivante : p1 = new Personne("Dupond", "Jacques", 24, 0601020304); On pourrait contracter lensemble de la faon suivante : c Personne p1 = new Personne("Dupond", "Jacques", 24, 0601020304); ` A partir de ce moment, lobjet est construit et on peut lutiliser normallement. Nous avions aussi dni une constructeur dit par copie . Voici la faon de e c lutiliser : Personne p2 = new Personne(p1); On cre une Personne p2 en copiant toute les informations contenues dans e p1.

11

3.2
3.2.1

Rfrence ee
Retour sur les variables

Dans un programme informatique, la manipulation de donnes se fait par e lintermdiaire de variables. Ces variables rsident en mmoire centrale sur la e e e pile dexcution. Une variable de type primitif (char, int, bool, . . . ) contient e directement sa valeur. Par contre, une variable dun type plus complexe (tableau, string, list, objet) contient une rfrence qui va pointer sur des donnes prsentes ee e e sur le tas. 3.2.2 Rfrences particuli`res ee e

Le mot clef this est utilis exclusivement dans la dnition dune classe e e comme rfrence ` lobjet courant. Ainsi, il ne peut tre utilis que dans des ee a e e mthodes et des proprits dinstance. Lutiliser dans des mthodes de classe e ee e serait un non-sens. Le mot clef null reprsente quant ` lui une absence de rfrence. Cest une e a ee mani`re dexpliciter quune variable est une coquille vide. Il peut tre aect ` e e ea toute variable. 3.2.3 Retour sur new

Le mot clef new nest utilis que lors de la construction dun nouvel objet. e Il permet lallocation dynamique de la mmoire ncssaire ` cette nouvelle inse e e a tance dans le tas. Il renvoie ainsi une rfrence vers la nouvelle instance cre. ee e Cette rfrence sera alors stocke dans la pile. Ce procd rend chaque instance ee e e e unique et toute modication dune proprit sur une instance naura aucune ee consquence sur une autre (` part si il sagit de champs de classes). e a 3.2.4 Rfrence et aectation ee

Imaginons que nous dclarons deux variable Personne p1 et p2 : e Personne p1 = new Personne("Dupond", "Jean", 44, 0601020304); Personne p2; p2 = p1; La question est de savoir ce quil va se passer au moment de p2 = p1. Premi`re remarque, nous navons pas utilis le mot clef new pour p2. Je nai e e donc pas construit de nouvel objet. Ainsi, les variables p2 et p1 pointent sur le mme objet. Elles ont donc la mme rfrence et on peut ` ce moment e e ee a utiliser indiremment p1 ou p2 pour agir sur lobjet considr. Retenez donc e e e que aectation et construction ne sont pas la mme chose. e 3.2.5 Comparaison de rfrence ee

Dans le cas ou le programmeur naurait pas surcharg les oprateurs == e e et != dune classe, ces deux oprateurs comparent deux rfrences. Ainsi, dans e ee lexemple prcdent, p1 == p2 retournera un rsultat positif. Il faut cependant e e e faire attention ` ne pas confondre comparer les rfrences avec comparer les a ee valeurs des objets.

12

3.3

Utilisation

La syntaxe pour manipuler les champs et mthodes dun objet suit le protoe type suivant : [nom de lobjet].[nom de la mthode ou du champ]. Par exemple, e dans le cas de lobjet p1 de type Personne : p1.nom. 3.3.1 Utilisation des champs

Nous avions dclar tous les champs comme private. Ce qui fait qu` la e e a compilation, la moindre occurence du type p1.nom, p2.telephone, . . . se traduira par une erreur de compilation pour violation du principe dencapsulation. Une solution serait de dclarer ces champs comme public. Cepedant, nous avions e utiliser le terme private pour des raisons de scurit et pour rendre le code e e plus fonctionnel. Pour accder aux champs, nous allons donc devoir utiliser les e proprits qui ont pour mrite dexpliciter la lecture et lcriture des champs. ee e e Personne p = new Personne("Jean", "Michelin", 34, 0601020304); Console.Out.WriteLine("p=(" + p.Prenom + "," + p.Nom + "," + p.Age + ")"); p.Age = 56; Console.Out.WriteLine("p=(" + p.Prenom + "," + p.Nom + "," + p.Age + ")"); La dnition de mthodes get au sein de ces proprits permet de lire les e e ee champs et la dnition de mthodes set permet tout simplement de modier la e e valeur de ces champs. Dans lexemple prcdent, labsence de set aurait entrain e e e une erreur de compilation pour p.Age = 56 et labsence de methode get aurait empch lachage sur la console. e e 3.3.2 Utilisation des mthodes et des oprateurs e e

Les oprateurs dnis ou surchargs dans des classes sutilisent exactement e e e de la mme faon que des oprateurs normaux. Il sut de faire bien attention ` e c e a leur dnition et ` leur fonctionnement et de les rendre le plus intuitifs possible. e a Par exemple, dnir un oprateur dans la cas de la classe Personne naurait e e aucun sens, alors quil en aurait un pour une classe Fraction. Concernant les mthodes, elles sutilisent de la mme faon quune fonce e c tion normale avec passage de param`tres et un type de sortie. Par exemple, la e mthode identie sera utiliser de la faon suivante : e c Personne p = new Personne("Jean", "Michelin", 34, 0601020304); Console.WriteLine(p.Identifie()); La fonction WriteLine demande un param`tre string, fournit par la sortie de e la mthode Identie. e Nanmoins, il faut garder en mmoire que les mthodes sont appeles e e e e par un objet et font donc partie dun cosyst`me particulier. e e

3.4

Exemple

Voici un exemple dutilisation de la classe Personne :

13

Personne p1 = new Personne("Jean", "Michelin", 34, 0601020304); Personne p2 = new Personne("Jean", "Micheline", 34, 0601020305); Personne p3 = new Personne(p1); Personne p4 = p2; Console.WriteLine(p1.Identifie()); Console.WriteLine(p3.Identifie()); p3.Age = 44; Console.WriteLine(p1.Identifie()); Console.WriteLine(p3.Identifie()); Console.WriteLine(p2.Identifie()); Console.WriteLine(p4.Identifie()); p2.Age = 44; Console.WriteLine(p2.Identifie()); Console.WriteLine(p4.Identifie()); Exercice : essayer de prvoir ce que le programme va acher dans la console. e

4
4.1

Hritage e
Concepts

Lhritage est une technique permettant de dnir une classe ` partir dune e e a classe existente. Par exemple, ` partir de la classe Personne apportant dj` les a ea champs nom, prenom, age, telephone ainsi que quelques proprits et mthodes, ee e nous allons pouvoir dnir dautres classes dite classes-lles. Par exemple, si e lon veut modliser le fonctionnement dune universit, nous pourrons crer les e e e classes tudiants, professeurs, personnels techniques,. . . ou pour modliser un e e avion de ligne, nous pourrons creer les classes pilotes, htesses et passagers. Ce o mcanisme est une spcialisation, ou une gnralisation selon les cas, ` partir e e e e a dune classe m`re regroupant leurs proprits communes. e ee Lhritage est donc un mcanisme de rutilisation du code ou seul les dirences e e e e entre les classes sont explicites. On parle alors de classe m`re et de classe lle. e e Une chose ` retenir en C#, lhritage est dit : hritage simple car une classe a e e lle ne peut peut avoir quune seule classe m`re (comme en Java) ` la dirence e a e dautres languages comme le C++. Une derni`re chose permise par lhritage est la rednition de mthodes e e e e nayant pas le fonctionnement souhait dans la classse lle. La mthode est e e alors rednie pour adapter son comportement. e Voici la syntaxe pour dclarer quune classe hrite de la classe m`re Pere e e sonne : public class Passager : Personne { 14

... } Cest le symbole : qui permet dexpliciter que la classe Passager et lhriti`re e e de la classe Personne.

4.2

Champs

Une classe lle conserve lensemble des champs de la classe m`re mais peut e nanmoins ajouter dautres champs. Par exemple, dans le cas dun passager, on e pourrait rajouter son numro de si`ge et le prix de son billet. e e public class Passager : Personne { //Champs private int siege; private double prix_billet; } Dans la cas dun pilote, on pourra rajouter son nombre dheures de vol ainsi que son salaire. public class Pilote : Personne { //Champs private int heures_vol; private double salaire; } Cependant, il faut faire attention ` lapplication du principe dencapsulation. a Mme si les classes Passager et Pilote sont tr`s proches de la classe Personne, e e le fait que les champs dnis dans Personne le soit avec le mot clef private e les oblige ` utiliser les proprits pour y accder. Ce mode de fonctionnement a ee e ntant pas tr`s pratique, il existe un autre mot clef permettant lacc`s des e e e champs dune classe ` ses classes lles : protected. Cela reviendrait ` dnir la a a e classe Personne de la mani`re suivante : e public class Personne { //Champs protected string nom; protected string prenom; protected int age; protected int telephone; } De cette mani`re, les classes Passager et Pilote peuvent utiliser ces champs e directement, facilitant la programmation. Retenez surtout que protected permet lacc`s au champs uniquement aux e classes-lles de Personne, tandis que public autorise cet acc`s ` lensemble du e a programme et que private restraint cet acc`s aux mthodes des objets de types e e Personne. 15

4.3

Constructeur

Contrairement aux mthodes, champs et proprits, une classe lle nhrite e ee e pas des constructeur de sa classe m`re. Les constructeurs doivent donc tre e e rednis. On peut cependant faire appel aux constructeurs de la classe m`re e e dans un soucis de rutilisation du code. e public Passager(string nom, string prenom, int age, int telephone, int siege, double prix_billet) : base(nom, prenom, age, telephone) { this.siege = siege; this.prix_billet = prix_billet; } Le mot clef base appelle le constructeur correspondant de la classe Personne. Si lappel par le mot clef base est absent, alors le compilateur va se tourner vers un constructeur sans param`tre de Personne, (qui doit tre pralablement e e e dnis) et renverra une erreur si ce contructeur nexiste pas. e Retenez bien quun objet Passager est aussi une Personne et doit donc tre e instanci comme une Personne avant de pouvoir tre dclarer comme un Passae e e ger.

4.4

Mthodes e

Certaines mthodes dune classe m`re peuvent ne plus tre adapte ` sa/ses e e e e a classe(s) lle(s). Il faut alors rednir la mthode en question. e e Par exemple, la mthode Identie() de la classe Personne ne permet pas de e rendre compte de lensemble des informations prsentes dans la classe Passager. e Il nous faut donc la complter de la mani`re suivante : e e public string Identifie() { string s = base.Identifie() + "," + this.siege + "," + this.prix_billet + ")"; return s; } Encore une fois, notez lutilisation du mot clef base de mani`re ` rutiliser e a e la mthode de la classe m`re. on pourrait tr`s bien se passer de lutilisation de e e e ce mot clef, lessentiel tant que la mthode Identie soit adapte ` la classe On e e e a aurait tout aussi bien crire cette mthode de la faon suivante : e e c public string Identifie() { string s = "p=(" + this.prenom + "," + this.nom + "," + this.age + "," + this.telephone + "," + this.siege + "," + this.prix_billet + ")"; return s; } Il faudra aussi penser ` rednir les oprateurs si ncessaire. a e e e 16

4.5

Remarques complmentaires e

La relation induite par lhritage simple permet de constituer un arbre e dhritage. Cet outil doit tre considr comme une aide ` la conception dun e e e e a programme permettant de hirarchiser ses classes et de voir si certaines peuvent e faire lobjet dune classe m`re commune permettant un gain de temps certain e au niveau de la programmation. Une derni`re prcision concernant le vocabulaire : une classe lle est aussi e e appelle une sous-classe et une classe m`re, une superclasse. e e

4.6

Exemple

Pour la classe m`re, reportez au code de la classe Personne dnis ` la e e a deuxi`me section. Seul les champs dinstance sont dclars comme protected e e e plutt que private. o public class Passager : Personne { //Champs private int siege; private double prix_billet; //Constructeur public Passager(string nom, string prenom, int age, int telephone, int siege, double prix_billet) : base(nom, prenom, age, telephone) { this.siege = siege; this.prix_billet = prix_billet; } //Proprits e e public int Siege { get { return this.siege; } set { this.siege = value; } } public double Prix_Billet { get { return this.prix_billet; } 17

set { this.prix_billet = value; } } //Oprateur e public static bool operator ==(Passager a, Passager b) { if(a.nom == b.nom && a.prenom == b.prenom && a.age == b.age && a.telephone == b.telephone && a.siege == b.siege && a.prix_billet == b.prix_billet) { return 1; } else return 0; } //Mthode e public string Identifie() { string s = base.Identifie() + "," + this.siege + "," + this.prix_billet + ")"; return s; } }

Littrature e
http ://www.csharp-station.com http ://csharp.net-tutorials.com Serge Tah. Apprentissage du langage C# 2008 et du Framework .NET e 3.5 (2008). (http ://tahe.developpez.com/dotnet/csharp/)

18