Licence professionnelle QCI Universit´ Robert Schuman e

Programmation orient´e objet e 2008/09

Programmation Objet - C#
c Benoˆ Caldairou, 2008 ıt

1
1.1

Introduction
Qu’est-ce que la programmation orient´e objet ? e

Contrairement ` la programmation dite imp´rative, qui n’est qu’un simple a e traitement sur des donn´es, la programmation orient´e 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 l’association d’une quantit´ d’informae e e tion organis´e en champs (nom, pr´nom, age, notes pour un ´tudiant ; marque, e e e mod`le, cylindr´e, vitesse pour une voiture) et d’un ensemble de m´thodes (plus e e e ou moins ´quivalentes ` des fonctions) permettant d’interagir avec lui (calculer e a la moyenne d’un ´tudiant ou acc´l´rer pour une voiture). e ee Cette technique de programmation a principalement deux objectifs : – Faciliter l’´criture des applications par une structuration en terme d’obe jets. – Favoriser la r´utilisation de code, en composant des programmes ` partir e a d’objets existants (par exemple, la biblioth`que standart de C++, de Java, e . . . ). Deux notions essentielles sont caract´ristiques de la POO : e – La notion de classe : sch´matiquement, une classe repr´sente le type d’un e e objet, tout comme int repr´sente un r´el. Elle peut ˆtre vu comme une e e e sorte de super-structure. – La notion de m´thode : sch´matiquement, une m´thode est une fonction e e e appartenant ` une classe et permettant d’agir sur et avec l’objet. a

1.2

Concepts clefs de la programmation orient´e objet e

La POO a introduit des concepts permettant une bien meilleure souplesse de programmation ainsi qu’une plus grande s´curit´. e e Dans un soucis de r´utilisation du code, une classe doit ˆtre sufisamment e e bien con¸u pour qu’un programmeur n’ait pas ` s’inqui´ter de l’´tat interne c a e e d’un objet, mais se contente de savoir de quelle mani`re il interagit avec son e environnement. Cette volont´ de masquer la repr´sentation de l’objet s’appelle e e l’encapsulation et am`ne aussi une s´curit´ du code dans la mesure ou l’´tat e e e e de l’objet ne peut ˆtre chang´ que de mani`re explicite. Cel` permet aussi de e e e a modifier la repr´sentation d’une classe sans forc´ment modifier les interactions e e et donc les programmes d´pendants de ces classes. e

1

de d´finir e e e l’´tat de l’objet. Au moment de sa destruction. e e e e e 1. ˆge et num´ro de t´l´phone e a e ee tout ´tant capable de modifier et d’afficher ces informations. e A sa cr´ation.3 1. appell´e un e e destructeur. e – un ou plusieurs constructeurs : ce sont des fonctions indiquant de quelle fa¸on l’objet doit ˆtre d´clar´ et initialis´. elle peuvent s’appliquer sur un objet particue lier. de la mˆme fa¸on e a e c qu’une variable. un fonction sp´ciale. un objet est contruit et initialis´ grˆce a un constructeur et il e e a ` va rester en m´moire jusqu’` la fin de la fonction qui l’emploie. ou sur l’ensemble des instances d’une classe. 1.1 Principales notions de base Classe Sch´matiquement. ee Une classe doit n´cessairement comporter les ´l´ments suivants : e ee – les champs : ce sont les « variables » permettant.3. e e La POO introduit enfin des concepts plus avanc´s tels que le polymorphisme e et la g´n´ricit´ qui seront abord´s ult´rieurement. de type personne ou de type ´l`ve. une classe d´clare un ensemble d’injonctions communes e e ` une famille d’objets (des attributs pour l’´tat de l’objet et des m´thodes a e e 2 . c e e e e – les m´thodes : ce sont les fonctions permettant d’agir sur les objets d’une e classe. par exemple un objet de type voie ture. en g´n´ral. une classe est la « description » d’une collection objets e homog`nes.Toujours dans un soucis d’efficacit´ et de modularit´. pr´nom. la POO a introduit la e e notion d’h´ritage entre les classes. on peut d´finir grˆce e e e e a ` l’h´ritage une classe dite « m`re » ` partir de laquelle on va d´finir plusieurs a e e a e classes dites « filles » ayant en commun les caract´ristiques de la classe m`re. e – pour d´finir un nouveau type d’objet. e e Cela permet une ´conomie du code et favorise sa r´utilisation. 2 Notion de classe Dans la suite de ce cours. Selon leur d´finition.2 Objet Nous avons vu pr´c´demment qu’un objet est une « instance » de classe. qui est ici masqu´ par le language C# (ainsi qu’en e e Java) contrairement ` d’autre languages orient´s objets comme le C++ qui a e n´cessitent une d´finition formelle du destructeur au mˆme titre que la d´finition e e e e d’un constructeur. La notion de classe peut ˆtre utilis´ de plusieurs fa¸ons : e e e c – pour d´finir un ensemble de sous-programmes (classes utilitaires) . est appel´e.1 G´n´ralit´s e e e De mani`re formelle. e 2. Tr`s sch´matiquement. nous allons consid´rer ` titre illustratif une classe e a Personne dont on veut stocker les nom. Par e e analogie.3. on peut aussi consid´rer une classe comme le type d’une variable et e l’objet comme la valeur de cette mˆme variable.

pr´nom. ´ventuellement e a ` partir de param`tres. En C#. une classe sera toujours d´finie de la mani`re suivante : e e public class Personne { //D´claration des champs e . private sera ajout´ par d´faut ` la compilation. //D´claration des m´thodes e e .repr´sentant le comportement de l’objet). Par convention. les champs repr´sentent les « variables » traduisant e l’´tat de l’objet (comme avec les champs des structures). int age. e e e e a 2. des listes. d’autres e objets. Le mot clef public devant le mot clef class indique que la classe Personne est accessible depuis n’importe quelle partie du programme..2 Champs Comme dit plus haut. Ces variables peuvent e ˆtre de toutes natures : des entiers. Un programmeur utilisant la classe personne ne pourra donc pas utiliser ces variables directement dans d’autres fonction sauf si private est remplac´ par le mot clef public. Un bon exemple de classe existante e est la classe string ou encore la classe list... //D´claration des contructeurs e . e Le mot clef private devant les champs indique ici que ces variables ne sont pas accessibles en dehors de la classe personne. e Plusieurs contructeurs peuvent ˆtre d´finis. leur nom commencent toujours par une minuscule. int telephone. age et num´ro de t´l´phone : e e ee public class { private private private private } Personne string nom. string prenom. } 2. . . etc.. Si aucun mot clef e n’est pr´cis´. Elle aura aussi son importance au moment ou nous aborderons l’h´ritage. des chaˆ e ınes de caract`res.3 Constructeurs Un contructeur est une fonction appell´e au moment de la cr´ation d’un objet e e a ` partir d’une classe. nous allons d´clarer les champs suie vants : nom. Il permet d’initialiser correctement cet objet.. Dans le cas de notre classe personne.. e e public class Personne { 3 .

int age.prenom. On appelle cela un constructeur par copie. nous allons donc d´finir e e des moyens d’acc´der ` ces variables ` travers des propri´t´s. } public personne(personne p) { this. this. Il est cependant essentiel de le d´finir afin d’´viter les e e e e surprises au moment de l’ex´cution et il est aussi utile si on d´finit une classee e fille comme nous le verrons ult´rieurement. il se peut que le programe meur ait besoin de connaitre ces informations et ait aussi besoin de les mettre ` a jour.nom = p. Elle permet d’acc´der ee e ` l’objet appelant depuis la m´thode et aussi d´viter les confusions lorsque deux a e e variables ont le mˆme nom. private int telephone. Une propri´t´ e a a ee ee permet de d´finir des acc`s en consultation (get ) et en modification (set ).telephone = p. dans le deuxi`me constructeur.age = p.nom permet de ne pas confondre le champ nom de l’objet personne e avec la variable nom pass´e en param`tre pour l’initialisation. Le troisi`me e e e constructeur est un constructeur particulier dans le sens ou il cr´e un objet pere sonne en copiant les informations contenues dans un autre objet personne. Cependant. Par exemple. Un e e 4 .age. private string prenom. this. le fait e e d’´crire this. } } Le mot clef this est une r´f´rence sur l’instance courante. int telephone) { this. this. ni ´crire de valeur dans ces variables. //Constructeurs public personne(){} //Constructeur par d´faut e public personne(string nom.telephone = telephone.prenom = prenom.4 Propri´t´s e e Nous avons vu qu’en rendant les champs priv´s.nom. this. Le premier constructeur est aussi un peu particulier vu qu’il ne prend aucun param`tre en entr´e.age = age. un programmeur utilisateur e de la classe personne ne pourra pas lire. Le e comportement de l’objet devient alors ´quivalent ` celui d’une boite noire dont e a on ne peut pas connaitre l’´tat interne. private int age. string prenom. Pour ´viter de violer le principe d’encapsulation.//Champs private string nom. this. e 2.telephone. this.nom = nom.prenom = p.

} else { nom = value. nom = null. } set { this.nom. } set { if (value == null || value.WriteLine("Nom Invalide").age = value. il vaut e mieux v´rifier que la param`tre pass´ ` set soit effectivement initialis´ et qu’il e e ea e ait une longueur sup´rieure ` 0. e a 2. pour ´viter qu’une erreur ne survienne au moment de l’execution. Elles sont assimilables ` des fonctions sauf qu’elles sont g´n´ralement a e e 5 .Trim().age.5 M´thodes e Les m´thodes sont des « sous-porgrammes » propres ` agir sur les objets e a d’une classe. } } } Ici. e La syntaxe d’une propri´t´ se d´finit de la mani`re suivante : ee e e public int Age { get { return this.Length == 0) { Console. Un autre exemple avec le champ nom : public string Nom { get { return this.acc`s en consultation ou en modification est possible uniquement si le get ou set e correspondant est d´finie. } } Le mot clef public indique bien que la propri´t´ peut ˆtre utilis´e dans n’imee 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.

Il suffit alors de d´clarer un champ d’instance de la mani`re suivante : e e private static int nbPersonne.telephone = telephone.ToLower().appel´s par des objets et agissent potentiellement sur eux. int telephone) { this. this.age. 6 . m´thodes et propri´t´s de classe e e e Les champs de classe sont des champs que les objets d’une mˆme classe vont e partager.age = p. string prenom. Reprenons notre classe Personne. De mˆme. this.1 M´thodes d’instance e Ces m´thodes d´crivent des op´rations effectu´es sur une instance partie e e e culi`re de la classe (c’est-`-dire sur un seul objet). int age. nbPersonne++. } public personne(personne p) { this. les m´thodes et les propri´t´s de classe sont des m´thodes e e ee e qui vont affecter l’ensemble des objets d’une classe.nom = nom. e 2.prenom = prenom. this. e a Un bon exemple est la m´thode de la classe string (chaˆ e ınes de caract`res) e ToLower() qui permet de passer toutes les lettres d’une chaˆ en minuscules ıne de la fa¸on suivante : c string s = new string("Une souris Verte qui Courait dans l’herBe").age = age.5. Nous aimerions disposer d’un compteur permettant de connaitre en permanence combien d’instances de Personne il existe. Cette op´ration va transformer le contenu de s en : une souris verte qui e courait dans le pr´.2 Champs. Remarquez au passage le mot clef static qui indique que ce champ est un champ de classe. this.prenom = p. s = s. Il faut alors red´finir les constructeur de la mani`re suivante : e e public class Personne { //Constructeurs public personne(){nbPersonne++.nom = p.5.} //Constructeur par d´fault e public personne(string nom.nom. this.prenom. e 2.

on d´finit une propri´t´ de e a e a e ee classe permettant un acc`s en lecture seule. ==. e e e e e cependant leur utilisation est plus intuitive..3 Surcharge de m´thodes e Nous avons vu pr´cedemment que nous pouvions donner plusieurs formes e de constructeur qui ayant pour objectifs d’initialiser un objet.6 Op´rateurs e Les op´rateurs d´finis pour une classe sont identifi´s par des symboles tels e e e que =.. IndexOf(string value.telephone. . ces op´rateurs e ne sont pas diff´rents des fonctions. +. ıne e //m´thodes e public int public int public int public int surcharg´es e IndexOf(char value).. } } De mani`re ` acc´der ` la variable nbPersonne. int startIndex). ). Cependant. On appelle cel` la surcharge de m´thode. Un exemple concret se e e trouve dans la classe string avec l’ensemble des m´thodes IndexOf(. La diff´rence entre ces m´thodes se fait par le nombre de param`tres. nbPersonne++. ¡=. . . pere mettant de chercher l’index (ou la position dans la chaˆ ıne) d’un caract`re ou e d’une sous-chaˆ de caract`res. d’un point de vue logique. Voici un exemple d’op´rateur permettant de savoir si deux personnes sont e identiques : 7 . . Il suffit d’ajouter le e e c mot clef static pour la d´clarer comme ´tant de classe. il est pr´f´rable de ne pas e ee laisser de possibilit´ au programmeur de modifier cette variable autrement qu’en e cr´ant diff´rentes personnes. mais avec des comportements diff´rents. On e e peut appeller plusieurs m´thodes par le mˆme nom (la logique veut que ces e e m´thodes aient un comportement similaire) tout en leur donnant des param`tres e e diff´rents..this. Cela s’applique aussi bien e a e aux m´thodes d’instance qu’aux m´thodes de classes. cela fonctionne de la mˆme fa¸on. En effet. -. e e public static long NbPersonne { get { return nbPersonne. . leur e e e type et leur ordre. IndexOf(string value). e Le C# autorise le mˆme genre de comportement pour les m´thodes. IndexOf(char value..telephone = p. Ils doivent ˆtre d´finis de la mˆme mani`re. 2. } } Pour les m´thodes. int startIndex)... 2. Elle s’appliquera alors e e sur l’ensemble des instances d’une classe..5.

telephone == b. e 2.WriteLine("p1 et p2 sont la m^me personne"). private string prenom.8 En exemple complet : la classe Personne Voici l’impl´mentation compl`te de la classe personne d´finie tout au long e e e de cette section : public class Personne { //Champ et propri´t´ de classe e e private static int nbPersonne. e a Par exemple dans le cas de notre classe Personne. ´tant donn´ que cet op´rateur doit pouvoir s’appliquer indiff´remment ` e e e e a n’importe quelles instances de la classe. public static long NbPersonne { get { return nbPersonne. private int telephone.telephone) return 1. Personne b) { if(a. } } //Champs d’instance private string nom.public static bool operator ==(Personne a. e 2.age && a. e else Console.prenom && a. private int age. else return 0.age == b. Dans le programme principale.nom == b. } Remarquez l’utilisation du mot clef static car il s’agit d’une « m´thode » de e classe. //Constructeurs 8 .7 Notions de mutabilit´ e Ce terme d´signe le fait qu’une instance de classe puisse ˆtre modifi´e ou e e e pas au cours de l’ex´cution du programme (c’est-`-dire modifier ses champs). Il suffirait de supprimer cette e possibilit´ pour rendre cette classe non mutable.WriteLine("p1 et p2 sont deux personnes diff´rentes").nom && a. le fait d’autoriser l’acc`s en e ´criture sur les champs rend la classe mutable.prenom == b. il sera utilis´ de la fa¸on suivante : e c //On suppose que deux instances de Personnes p1 et p2 //ont d´j` ´t´ initialis´e e a e e e if(p1 == p2) Console.

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

} else { prenom = value.tele return 1.age. else return 0.Trim().nom == b. e prenom = null. } } //Op´rateur e public static bool operator ==(Personne a. } set { this.age && a.prenom && a.Length == 0) { Console.telephone == b. } set { this.{ if (value == null || value. } } } public int Age { get { return this.WriteLine("Pr´nom Invalide").prenom == b.nom && a.age = value. } //M´thode e public string Identifie() 10 .age == b.telephone = value.telephone. Personne b) { if(a. } } public int Telephone { get { return this.

" + p. Tandis qu’une classe est e une repr´sentation abstraite. Voici la fa¸on de e c l’utiliser : Personne p2 = new Personne(p1). Mais cette variable n’est rien de plus qu’une coquille vide. Nous avions aussi d´fini une constructeur dit « par copie ». On cr´e une Personne p2 en copiant toute les informations contenues dans e p1. si vous vous contentez de d´clarer : e Personne p1.1 Cr´ation e La cr´ation d’un objet ob´it ` des r`gles logiques et syntaxiques particuli`re. 0601020304). 0601020304).prenom + ". 24. "Jacques". l’objet repr´sente quelque chose de tr`s concret vu e e e qu’il est stock´ en m´moire et qu’on peut agir sur lui par le biais des m´thodes. Les champs ne sont pas remplit et il est impossible d’utiliser les m´thodes pour la simple et bonne raison que la Personne p1 n’existe pas encore.age + ". un objet est une instance d’une classe. ` A partir de ce moment. "Jacques". e 3." + p. Pour ce faire. il va falloir contruire a la Personne. On pourrait contracter l’ensemble de la fa¸on suivante : c Personne p1 = new Personne("Dupond".telephone ") return s. } } 3 Notion d’objet Par d´finition. 11 . l’objet est construit et on peut l’utiliser normallement. rien ne va se passer. nous utilisons la syntaxe suivante : p1 = new Personne("Dupond".{ string s = "p=(" + this.nom + ". Il faut comprendre que vous vous ˆtes content´ de d´clarer e e e une variable de type Personne. e e a e e En effet." + this. e Pour pouvoir utiliser cette variable ` notre convenance. 24. Un exemple pour illustrer ce propos : la plan d’une ee e maison repr´sente la classe et on peut contruire une multitude de maison sur ce e mod`le. e e e propri´t´s et op´rateurs.

ces deux op´rateurs comparent deux r´f´rences. La question est de savoir ce qu’il va se passer au moment de p2 = p1. ) contient e directement sa valeur. Ainsi. Retenez donc e e e que affectation et construction ne sont pas la mˆme chose. 3.1 R´f´rence ee Retour sur les variables Dans un programme informatique. Ce proc´d´ rend chaque instance ee e e e unique et toute modification d’une propri´t´ sur une instance n’aura aucune ee cons´quence sur une autre (` part si il s’agit de champs de classes).2 R´f´rences particuli`res ee e Le mot clef this est utilis´ exclusivement dans la d´finition d’une classe e e comme r´f´rence ` l’objet courant. C’est une e a ee mani`re d’expliciter qu’une variable est une coquille vide. int. Elles ont donc la mˆme r´f´rence et on peut ` ce moment e e ee a utiliser indiff´remment p1 ou p2 pour agir sur l’objet consid´r´. objet) contient une r´f´rence qui va pointer sur des donn´es pr´sentes ee e e sur le tas. Je n’ai e e donc pas construit de nouvel objet. "Jean".2. Par contre. il ne peut ˆtre utilis´ que dans des ee a e e m´thodes et des propri´t´s d’instance. .4 R´f´rence et affectation ee Imaginons que nous d´clarons deux variable Personne p1 et p2 : e Personne p1 = new Personne("Dupond".2.5 Comparaison de r´f´rence ee Dans le cas ou le programmeur n’aurait pas surcharg´ les op´rateurs == e e et != d’une classe. 0601020304). string. Il peut ˆtre affect´ ` e e ea toute variable. Ainsi. 12 . p2 = p1. Ces variables r´sident en m´moire centrale sur la e e e pile d’ex´cution. une variable d’un type plus complexe (tableau.3. L’utiliser dans des m´thodes de classe e ee e serait un non-sens.2. e a 3. 3. . Le mot clef null repr´sente quant ` lui une absence de r´f´rence. Il renvoie ainsi une r´f´rence vers la nouvelle instance cr´e. Personne p2. list. dans e ee l’exemple pr´c´dent. bool. e 3. Premi`re remarque. . Ainsi. p1 == p2 retournera un r´sultat positif. Une variable de type primitif (char. 44.3 Retour sur new Le mot clef new n’est utilis´ que lors de la construction d’un nouvel objet.2 3. e Il permet l’allocation dynamique de la m´moire n´c´ssaire ` cette nouvelle inse e e a tance dans le tas.2. les variables p2 et p1 « pointent » sur le mˆme objet.2. la manipulation de donn´es se fait par e l’interm´diaire de variables. ee e Cette r´f´rence sera alors stock´e dans la pile. Il faut cependant e e e faire attention ` ne pas confondre comparer les r´f´rences avec comparer les a ee valeurs des objets. nous n’avons pas utilis´ le mot clef new pour p2.

4 Exemple Voici un exemple d’utilisation de la classe Personne : 13 . e e 3.nom. 3.3. 0601020304)." + p.[nom de la m´thode ou du champ]." + p. 0601020304).Age + ")"). e dans le cas de l’objet p1 de type Personne : p1.3 Utilisation La syntaxe pour manipuler les champs et m´thodes d’un objet suit le protoe type suivant : [nom de l’objet]." + p.telephone. 34. Console. alors qu’il en aurait un pour une classe Fraction. . p. "Michelin". Console.2 Utilisation des m´thodes et des op´rateurs e e Les op´rateurs d´finis ou surcharg´s dans des classes s’utilisent exactement e e e de la mˆme fa¸on que des op´rateurs normaux. Console. 34. Cepedant. p2.Nom + ". Il suffit de faire bien attention ` e c e a leur d´finition et ` leur fonctionnement et de les rendre le plus intuitifs possible.Out.nom. Une solution serait de d´clarer ces champs comme public.1 Utilisation des champs Nous avions d´clar´ tous les champs comme private. elles s’utilisent de la mˆme fa¸on qu’une fonce e c tion normale avec passage de param`tres et un type de sortie.Age = 56 et l’absence de methode get aurait empˆch´ l’affichage sur la console. La d´finition de m´thodes get au sein de ces propri´t´s permet de lire les e e ee champs et la d´finition de m´thodes set permet tout simplement de modifier la e e valeur de ces champs. d´finir un op´rateur ¿ dans la cas de la classe Personne n’aurait e e aucun sens.Prenom + ". Par exemple. Pour acc´der aux champs. nous allons donc devoir utiliser les e propri´t´s qui ont pour m´rite d’expliciter la lecture et l’´criture des champs.WriteLine("p=(" + p.WriteLine("p=(" + p.Identifie()). la e m´thode identifie sera utiliser de la fa¸on suivante : e c Personne p = new Personne("Jean". Dans l’exemple pr´c´dent. . l’absence de set aurait entrain´ e e e une erreur de compilation pour p. la moindre occurence du type p1. e e 3. il faut garder en m´moire que les m´thodes sont « appel´es » e e e e par un objet et font donc partie d’un ´cosyst`me particulier. e N´anmoins.Age + ")").WriteLine(p. .Prenom + ".Age = 56.Out. Ce qui fait qu’` la e e a compilation.Nom + ". nous avions e utiliser le terme private pour des raisons de s´curit´ et pour rendre le code e e plus fonctionnel. se traduira par une erreur de compilation pour violation du principe d’encapsulation.3. ee e e Personne p = new Personne("Jean".3. "Michelin". La fonction WriteLine demande un param`tre string. Concernant les m´thodes." + p. fournit par la sortie de e la m´thode Identifie. e a Par exemple. Par exemple.

WriteLine(p2. personnels techniques. p2.WriteLine(p4.WriteLine(p2. ` partir de la classe Personne apportant d´j` les a ea champs nom. Console. . "Michelin". Personne p3 = new Personne(p1).WriteLine(p3. nous pourrons cr´er les e e e classes ´tudiants. 34. Console. On parle alors de classe m`re et de classe fille.Identifie()). 0601020305).Identifie()). nous pourrons creer les classes pilotes.1 H´ritage e Concepts L’h´ritage est une technique permettant de d´finir une classe ` partir d’une e e a classe existente. telephone ainsi que quelques propri´t´s et m´thodes. l’h´ritage est dit : h´ritage simple car une classe a e e fille ne peut peut avoir qu’une seule classe m`re (comme en Java) ` la diff´rence e a e d’autres languages comme le C++. ou pour mod´liser un e e avion de ligne.Identifie()).WriteLine(p3.Age = 44.WriteLine(p4..Identifie()). ` partir e e e e a d’une classe m`re regroupant leurs propri´t´s communes. Console. La m´thode est e e alors red´finie pour adapter son comportement. Ce o m´canisme est une sp´cialisation. Personne p2 = new Personne("Jean". Par exemple. e ee L’h´ritage est donc un m´canisme de r´utilisation du code ou seul les diff´rences e e e e entre les classes sont explicit´es. Console. age.Personne p1 = new Personne("Jean". Console. professeurs. Exercice : essayer de pr´voir ce que le programme va afficher dans la console.Identifie()).Age = 44. Personne p4 = p2. Une derni`re chose permise par l’h´ritage est la red´finition de m´thodes e e e e n’ayant pas le fonctionnement souhait´ dans la classse fille. ou une g´n´ralisation selon les cas. . 0601020304).Identifie()).Identifie()).WriteLine(p1. e e Une chose ` retenir en C#. hˆtesses et passagers. "Micheline". p3. Console. e 4 4. Par exemple. si e l’on veut mod´liser le fonctionnement d’une universit´. ee e nous allons pouvoir d´finir d’autres classes dite classes-filles. 34.WriteLine(p1. e Voici la syntaxe pour d´clarer qu’une classe h´rite de la classe m`re Pere e e sonne : public class Passager : Personne { 14 .Identifie()). prenom. Console. Console.

Cela reviendrait ` d´finir la a a e classe Personne de la mani`re suivante : e public class Personne { //Champs protected string nom. } De cette mani`re. private double prix_billet. facilitant la programmation.. on e pourrait rajouter son num´ro de si`ge et le prix de son billet. il existe un autre mot clef permettant l’acc`s des e e e champs d’une classe ` ses classes filles : protected. 15 . e e le fait que les champs d´finis dans Personne le soit avec le mot clef private e les oblige ` utiliser les propri´t´s pour y acc´der. private double salaire.2 Champs Une classe fille conserve l’ensemble des champs de la classe m`re mais peut e n´anmoins ajouter d’autres champs. protected string prenom. protected int age. protected int telephone. a Mˆme si les classes Passager et Pilote sont tr`s proches de la classe Personne. dans le cas d’un passager. 4. } C’est le symbole : qui permet d’expliciter que la classe Passager et l’h´riti`re e e de la classe Personne. tandis que public autorise cet acc`s ` l’ensemble du e a programme et que private restraint cet acc`s aux m´thodes des objets de types e e Personne. Retenez surtout que protected permet l’acc`s au champs uniquement aux e classes-filles de Personne.. } Cependant.. public class Pilote : Personne { //Champs private int heures_vol. Ce mode de fonctionnement a ee e n’´tant pas tr`s pratique. on pourra rajouter son nombre d’heures de vol ainsi que son salaire. } Dans la cas d’un pilote. e e public class Passager : Personne { //Champs private int siege. les classes Passager et Pilote peuvent utiliser ces champs e directement. Par exemple. il faut faire attention ` l’application du principe d’encapsulation.

prix_billet + ")". e Il nous faut donc la compl´ter de la mani`re suivante : e e public string Identifie() { string s = base. int siege." + this. (qui doit ˆtre pr´alablement e e e d´finis) et renverra une erreur si ce contructeur n’existe pas." + this. } Le mot clef base appelle le constructeur correspondant de la classe Personne." + this. 4. prenom. l’essentiel ´tant que la m´thode Identifie soit adapt´e ` la classe On e e e a aurait tout aussi bien ´crire cette m´thode de la fa¸on suivante : e e c public string Identifie() { string s = "p=(" + this.nom + ". } Il faudra aussi penser ` red´finir les op´rateurs si n´cessaire. telephone) { this. age." + this.siege = siege. } Encore une fois.Identifie() + ".siege + ". champs et propri´t´s.3 Constructeur Contrairement aux m´thodes. this.siege + ".age + ". int age.prix_billet + ")". return s. Les constructeurs doivent donc ˆtre e e red´finis.4 M´thodes e Certaines m´thodes d’une classe m`re peuvent ne plus ˆtre adapt´e ` sa/ses e e e e a classe(s) fille(s).prenom + ". Si l’appel par le mot clef base est absent. e e Par exemple. notez l’utilisation du mot clef base de mani`re ` r´utiliser e a e la m´thode de la classe m`re. double prix_billet) : base(nom. alors le compilateur va se tourner vers un constructeur sans param`tre de Personne. une classe fille n’h´rite e ee e pas des constructeur de sa classe m`re.prix_billet = prix_billet. e Retenez bien qu’un objet Passager est aussi une Personne et doit donc ˆtre e instanci´ comme une Personne avant de pouvoir ˆtre d´clarer comme un Passae e e ger. return s. on pourrait tr`s bien se passer de l’utilisation de e e e ce mot clef." + this. string prenom. a e e e 16 ." + this. On peut cependant faire appel aux constructeurs de la classe m`re e e dans un soucis de r´utilisation du code. e public Passager(string nom.telephone + ".4. la m´thode Identifie() de la classe Personne ne permet pas de e rendre compte de l’ensemble des informations pr´sentes dans la classe Passager." + this. int telephone. Il faut alors red´finir la m´thode en question.

} } public double Prix_Billet { get { return this.siege = value. e e 4. int telephone.5 Remarques compl´mentaires e La relation induite par l’h´ritage simple permet de constituer un arbre e d’h´ritage. prenom. //Constructeur public Passager(string nom.siege = siege. Seul les champs d’instance sont d´clar´s comme protected e e e plutˆt que private. reportez au code de la classe Personne d´finis ` la e e a deuxi`me section. } 17 . int siege.prix_billet = prix_billet.prix_billet. } //Propri´t´s e e public int Siege { get { return this. une superclasse. } set { this.siege.4.6 Exemple Pour la classe m`re. this. string prenom. age. telephone) { this. double prix_billet) : base(nom. Une derni`re pr´cision concernant le vocabulaire : une classe fille est aussi e e appell´e une sous-classe et une classe m`re. int age. o public class Passager : Personne { //Champs private int siege. Cet outil doit ˆtre consid´r´ comme une aide ` la conception d’un e e e e a programme permettant de hi´rarchiser ses classes et de voir si certaines peuvent e faire l’objet d’une classe m`re commune permettant un gain de temps certain e au niveau de la programmation. private double prix_billet.

nom == b.Identifie() + ".csharp-station.prix_billet = value.siege && a.age && a. } } Litt´rature e – http ://www. Apprentissage du langage C# 2008 et du Framework . (http ://tahe.siege == b.com – Serge Tah´. } } //Op´rateur e public static bool operator ==(Passager a.prenom && a.prenom == b.developpez. } //M´thode e public string Identifie() { string s = base.com – http ://csharp.prix_billet) { return 1.nom && a. Passager b) { if(a.net-tutorials.telephone == b. return s.com/dotnet/csharp/) 18 .prix_billet + ")".telephone && a." + this.NET e 3. } else return 0.siege + ".set { this.prix_billet == b." + this.5 (2008).age == b.

Sign up to vote on this title
UsefulNot useful