.NET

1,204 views

Published on

Published in: Education
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,204
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
31
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

.NET

  1. 1. Licence professionnelle QCI Programmation orient´e objet eUniversit´ Robert Schuman e 2008/09 Programmation Objet - C# c Benoˆ Caldairou, 2008 ıt1 Introduction1.1 Qu’est-ce que la programmation orient´e objet ? e Contrairement ` la programmation dite imp´rative, qui n’est qu’un simple a etraitement sur des donn´es, la programmation orient´e objet (ou POO) est une e etechnique visant ` faire interagir des objets entre eux, permettant une meilleure amodularit´ et une plus grande souplesse de la programmation. e Ainsi, un objet va ˆtre constitu´ par l’association d’une quantit´ d’informa- e e etion organis´e en champs (nom, pr´nom, age, notes pour un ´tudiant ; marque, e e emod`le, cylindr´e, vitesse pour une voiture) et d’un ensemble de m´thodes (plus e e eou moins ´quivalentes ` des fonctions) permettant d’interagir avec lui (calculer e ala 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’ob- e 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. a1.2 Concepts clefs de la programmation orient´e objet e La POO a introduit des concepts permettant une bien meilleure souplessede programmation ainsi qu’une plus grande s´curit´. e e Dans un soucis de r´utilisation du code, une classe doit ˆtre sufisamment e ebien con¸u pour qu’un programmeur n’ait pas ` s’inqui´ter de l’´tat interne c a e ed’un objet, mais se contente de savoir de quelle mani`re il interagit avec son eenvironnement. Cette volont´ de masquer la repr´sentation de l’objet s’appelle e el’encapsulation et am`ne aussi une s´curit´ du code dans la mesure ou l’´tat e e e ede l’objet ne peut ˆtre chang´ que de mani`re explicite. Cel` permet aussi de e e e amodifier la repr´sentation d’une classe sans forc´ment modifier les interactions e eet donc les programmes d´pendants de ces classes. e 1
  2. 2. Toujours dans un soucis d’efficacit´ et de modularit´, la POO a introduit la e enotion d’h´ritage entre les classes. Tr`s sch´matiquement, 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 plusieursa e e a eclasses dites « filles » ayant en commun les caract´ristiques de la classe m`re. e eCela permet une ´conomie du code et favorise sa r´utilisation. e e La POO introduit enfin des concepts plus avanc´s tels que le polymorphisme eet la g´n´ricit´ qui seront abord´s ult´rieurement. e e e e e1.3 Principales notions de base1.3.1 Classe Sch´matiquement, une classe est la « description » d’une collection objets ehomog`nes. 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) ; e – pour d´finir un nouveau type d’objet, par exemple un objet de type voi- e ture, de type personne ou de type ´l`ve. ee Une classe doit n´cessairement comporter les ´l´ments suivants : e ee – les champs : ce sont les « variables » permettant, en g´n´ral, de d´finir e e e l’´tat de l’objet. e – un ou plusieurs constructeurs : ce sont des fonctions indiquant de quelle fa¸on l’objet doit ˆtre d´clar´ et initialis´. c e e e e – les m´thodes : ce sont les fonctions permettant d’agir sur les objets d’une e classe. Selon leur d´finition, elle peuvent s’appliquer sur un objet particu- e lier, ou sur l’ensemble des instances d’une classe.1.3.2 Objet Nous avons vu pr´c´demment qu’un objet est une « instance » de classe. Par e eanalogie, on peut aussi consid´rer une classe comme le type d’une variable et el’objet comme la valeur de cette mˆme variable. e A sa cr´ation, 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, de la mˆme fa¸on e a e cqu’une variable. Au moment de sa destruction, un fonction sp´ciale, appell´e un e edestructeur, est appel´e, qui est ici masqu´ par le language C# (ainsi qu’en e eJava) contrairement ` d’autre languages orient´s objets comme le C++ qui a en´cessitent une d´finition formelle du destructeur au mˆme titre que la d´finition e e e ed’un constructeur.2 Notion de classe Dans la suite de ce cours, nous allons consid´rer ` titre illustratif une classe e aPersonne dont on veut stocker les nom, pr´nom, ˆge et num´ro de t´l´phone e a e eetout ´tant capable de modifier et d’afficher ces informations. e2.1 G´n´ralit´s e e e De mani`re formelle, 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´thodesa e e 2
  3. 3. repr´sentant le comportement de l’objet). Un bon exemple de classe existante eest la classe string ou encore la classe list. En C#, une classe sera toujours d´finie de la mani`re suivante : e epublic class Personne{ //D´claration des champs e... //D´claration des contructeurs e... //D´claration des m´thodes e e...}2.2 Champs Comme dit plus haut, les champs repr´sentent les « variables » traduisant el’´tat de l’objet (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, d’autres eobjets, etc. . . Par convention, leur nom commencent toujours par une minuscule. Dans le cas de notre classe personne, nous allons d´clarer les champs sui- evants : nom, pr´nom, age et num´ro de t´l´phone : e e eepublic class Personne{ private string nom; private string prenom; private int age; private int telephone;} Le mot clef public devant le mot clef class indique que la classe Personneest accessible depuis n’importe quelle partie du programme. Elle aura aussi sonimportance au moment ou nous aborderons l’h´ritage. e Le mot clef private devant les champs indique ici que ces variables ne sont pasaccessibles en dehors de la classe personne. Un programmeur utilisant la classepersonne ne pourra donc pas utiliser ces variables directement dans d’autresfonction sauf si private est remplac´ par le mot clef public. Si aucun mot clef en’est pr´cis´, private sera ajout´ par d´faut ` la compilation. e e e e a2.3 Constructeurs Un contructeur est une fonction appell´e au moment de la cr´ation d’un objet e e` partir d’une classe. Il permet d’initialiser correctement cet objet, ´ventuellementa ea` partir de param`tres. e Plusieurs contructeurs peuvent ˆtre d´finis. e epublic class Personne{ 3
  4. 4. //Champs private string nom; private string prenom; private int age; private int telephone; //Constructeurs public personne(){} //Constructeur par d´faut 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 r´f´rence sur l’instance courante. Elle permet d’acc´der ee e` l’objet appelant depuis la m´thode et aussi d´viter les confusions lorsque deuxa e evariables ont le mˆme nom. Par exemple, dans le deuxi`me constructeur, le fait e ed’´crire this.nom permet de ne pas confondre le champ nom de l’objet personne eavec la variable nom pass´e en param`tre pour l’initialisation. Le troisi`me e e econstructeur est un constructeur particulier dans le sens ou il cr´e un objet per- esonne en copiant les informations contenues dans un autre objet personne. Onappelle cela un constructeur par copie. Le premier constructeur est aussi un peu particulier vu qu’il ne prend aucunparam`tre en entr´e. Il est cependant essentiel de le d´finir afin d’´viter les e e e esurprises au moment de l’ex´cution et il est aussi utile si on d´finit une classe- e efille comme nous le verrons ult´rieurement. e2.4 Propri´t´s e e Nous avons vu qu’en rendant les champs priv´s, un programmeur utilisateur ede la classe personne ne pourra pas lire, ni ´crire de valeur dans ces variables. Le ecomportement de l’objet devient alors ´quivalent ` celui d’une boite noire dont e aon ne peut pas connaitre l’´tat interne. Cependant, il se peut que le program- emeur ait besoin de connaitre ces informations et ait aussi besoin de les mettre ` ajour. Pour ´viter de violer le principe d’encapsulation, nous allons donc d´finir e edes moyens d’acc´der ` ces variables ` travers des propri´t´s. Une propri´t´ e a a ee eepermet de d´finir des acc`s en consultation (get ) et en modification (set ). Un e e 4
  5. 5. acc`s en consultation ou en modification est possible uniquement si le get ou set ecorrespondant est d´finie. e La syntaxe d’une propri´t´ se d´finit 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 propri´t´ peut ˆtre utilis´e dans n’im- ee e eporte quelle partie du code et que le mot clef int indique bien que get renvoieune 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 qu’une erreur ne survienne au moment de l’execution, il vaut emieux v´rifier que la param`tre pass´ ` set soit effectivement initialis´ et qu’il e e ea eait une longueur sup´rieure ` 0. e a2.5 M´thodes e Les m´thodes sont des « sous-porgrammes » propres ` agir sur les objets e ad’une classe. Elles sont assimilables ` des fonctions sauf qu’elles sont g´n´ralement a e e 5
  6. 6. appel´s par des objets et agissent potentiellement sur eux. e2.5.1 M´thodes d’instance e Ces m´thodes d´crivent des op´rations effectu´es sur une instance parti- e e e eculi`re de la classe (c’est-`-dire sur un seul objet). e a Un bon exemple est la m´thode de la classe string (chaˆ e ınes de caract`res) eToLower() qui permet de passer toutes les lettres d’une chaˆ en minuscules ınede la fa¸on suivante : cstring s = new string("Une souris Verte qui Courait dans l’herBe");s = s.ToLower(); Cette op´ration va transformer le contenu de s en : une souris verte qui ecourait dans le pr´. e2.5.2 Champs, 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 epartager. De mˆme, les m´thodes et les propri´t´s de classe sont des m´thodes e e ee equi vont affecter l’ensemble des objets d’une classe. Reprenons notre classe Personne. Nous aimerions disposer d’un compteurpermettant de connaitre en permanence combien d’instances de Personne ilexiste. Il suffit alors de d´clarer un champ d’instance de la mani`re suivante : e e private static int nbPersonne; Remarquez au passage le mot clef static qui indique que ce champ est unchamp de classe. Il faut alors red´finir les constructeur de la mani`re suivante : e epublic class Personne{ //Constructeurs public personne(){nbPersonne++;} //Constructeur par d´fault 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
  7. 7. this.telephone = p.telephone; nbPersonne++; }} De mani`re ` acc´der ` la variable nbPersonne, on d´finit une propri´t´ de e a e a e eeclasse permettant un acc`s en lecture seule. En effet, il est pr´f´rable de ne pas e eelaisser de possibilit´ au programmeur de modifier cette variable autrement qu’en ecr´ant diff´rentes personnes. e e public static long NbPersonne { get { return nbPersonne; } } Pour les m´thodes, cela fonctionne de la mˆme fa¸on. Il suffit d’ajouter le e e cmot clef static pour la d´clarer comme ´tant de classe. Elle s’appliquera alors e esur l’ensemble des instances d’une classe.2.5.3 Surcharge de m´thodes e Nous avons vu pr´cedemment que nous pouvions donner plusieurs formes ede constructeur qui ayant pour objectifs d’initialiser un objet, mais avec descomportements diff´rents. e Le C# autorise le mˆme genre de comportement pour les m´thodes. On e epeut appeller plusieurs m´thodes par le mˆme nom (la logique veut que ces e em´thodes aient un comportement similaire) tout en leur donnant des param`tres e ediff´rents. On appelle cel` la surcharge de m´thode. Cela s’applique aussi bien e a eaux m´thodes d’instance qu’aux m´thodes de classes. Un exemple concret se e etrouve dans la classe string avec l’ensemble des m´thodes IndexOf(. . . ), per- emettant de chercher l’index (ou la position dans la chaˆıne) d’un caract`re ou ed’une sous-chaˆ de caract`res. ıne e //m´thodes e surcharg´es e public int IndexOf(char value)... public int IndexOf(string value)... public int IndexOf(char value, int startIndex)... public int IndexOf(string value, int startIndex)... La diff´rence entre ces m´thodes se fait par le nombre de param`tres, leur e e etype et leur ordre.2.6 Op´rateurs e Les op´rateurs d´finis pour une classe sont identifi´s par des symboles tels e e eque =, +, -, ==, ¡=, . . . Cependant, d’un point de vue logique, ces op´rateurs ene sont pas diff´rents des fonctions. Ils doivent ˆtre d´finis de la mˆme mani`re, e e e e ecependant leur utilisation est plus intuitive. Voici un exemple d’op´rateur permettant de savoir si deux personnes sont eidentiques : 7
  8. 8. 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 l’utilisation du mot clef static car il s’agit d’une « m´thode » de eclasse, ´tant donn´ que cet op´rateur doit pouvoir s’appliquer indiff´remment ` e e e e an’importe quelles instances de la classe. Dans le programme principale, 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.WriteLine("p1 et p2 sont la m^me personne"); e else Console.WriteLine("p1 et p2 sont deux personnes diff´rentes"); e2.7 Notions de mutabilit´ e Ce terme d´signe le fait qu’une instance de classe puisse ˆtre modifi´e ou e e epas au cours de l’ex´cution du programme (c’est-`-dire modifier ses champs). e aPar exemple dans le cas de notre classe Personne, le fait d’autoriser l’acc`s en e´criture sur les champs rend la classe mutable. Il suffirait de supprimer cetteepossibilit´ pour rendre cette classe non mutable. e2.8 En exemple complet : la classe Personne Voici l’impl´mentation compl`te de la classe personne d´finie tout au long e e ede cette section :public class Personne{ //Champ et propri´t´ de classe e e private static int nbPersonne; public static long NbPersonne { get { return nbPersonne; } } //Champs d’instance private string nom; private string prenom; private int age; private int telephone; //Constructeurs 8
  9. 9. public personne(){nbPersonne++;} //Constructeur par d´fault epublic 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++;}//Propri´t´ e epublic 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
  10. 10. { if (value == null || value.Trim().Length == 0) { Console.WriteLine("Pr´nom 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; }}//Op´rateur epublic 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;}//M´thode epublic string Identifie() 10
  11. 11. { string s = "p=(" + this.prenom + "," + this.nom + "," + p.age + "," + p.telephone ") return s; }}3 Notion d’objet Par d´finition, un objet est une instance d’une classe. Tandis qu’une classe est eune repr´sentation abstraite, l’objet repr´sente quelque chose de tr`s concret vu e e equ’il est stock´ en m´moire et qu’on peut agir sur lui par le biais des m´thodes, e e epropri´t´s et op´rateurs. Un exemple pour illustrer ce propos : la plan d’une ee emaison repr´sente la classe et on peut contruire une multitude de maison sur ce emod`le. e3.1 Cr´ation e La cr´ation d’un objet ob´it ` des r`gles logiques et syntaxiques particuli`re. e e a e eEn effet, si vous vous contentez de d´clarer : ePersonne p1;rien ne va se passer. Il faut comprendre que vous vous ˆtes content´ de d´clarer e e eune variable de type Personne. Mais cette variable n’est rien de plus qu’unecoquille vide. Les champs ne sont pas remplit et il est impossible d’utiliser lesm´thodes pour la simple et bonne raison que la Personne p1 n’existe pas encore. e Pour pouvoir utiliser cette variable ` notre convenance, il va falloir contruire ala Personne. Pour ce faire, nous utilisons la syntaxe suivante :p1 = new Personne("Dupond", "Jacques", 24, 0601020304); On pourrait contracter l’ensemble de la fa¸on suivante : cPersonne p1 = new Personne("Dupond", "Jacques", 24, 0601020304); ` A partir de ce moment, l’objet est construit et on peut l’utiliser normalle-ment. Nous avions aussi d´fini une constructeur dit « par copie ». Voici la fa¸on de e cl’utiliser :Personne p2 = new Personne(p1); On cr´e une Personne p2 en copiant toute les informations contenues dans ep1. 11
  12. 12. 3.2 R´f´rence ee3.2.1 Retour sur les variables Dans un programme informatique, la manipulation de donn´es se fait par el’interm´diaire de variables. Ces variables r´sident en m´moire centrale sur la e e epile d’ex´cution. Une variable de type primitif (char, int, bool, . . . ) contient edirectement sa valeur. Par contre, une variable d’un type plus complexe (tableau,string, list, objet) contient une r´f´rence qui va pointer sur des donn´es pr´sentes ee e esur le tas.3.2.2 R´f´rences particuli`res ee e Le mot clef this est utilis´ exclusivement dans la d´finition d’une classe e ecomme r´f´rence ` l’objet courant. Ainsi, il ne peut ˆtre utilis´ que dans des ee a e em´thodes et des propri´t´s d’instance. L’utiliser dans des m´thodes de classe e ee eserait un non-sens. Le mot clef null repr´sente quant ` lui une absence de r´f´rence. C’est une e a eemani`re d’expliciter qu’une variable est une coquille vide. Il peut ˆtre affect´ ` e e eatoute variable.3.2.3 Retour sur new Le mot clef new n’est utilis´ que lors de la construction d’un nouvel objet. eIl permet l’allocation dynamique de la m´moire n´c´ssaire ` cette nouvelle ins- e e e atance dans le tas. Il renvoie ainsi une r´f´rence vers la nouvelle instance cr´e. ee eCette r´f´rence sera alors stock´e dans la pile. Ce proc´d´ rend chaque instance ee e e eunique et toute modification d’une propri´t´ sur une instance n’aura aucune eecons´quence sur une autre (` part si il s’agit de champs de classes). e a3.2.4 R´f´rence et affectation ee Imaginons que nous d´clarons 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 qu’il va se passer au moment de p2 = p1.Premi`re remarque, nous n’avons pas utilis´ le mot clef new pour p2. Je n’ai e edonc pas construit de nouvel objet. Ainsi, les variables p2 et p1 « pointent »sur le mˆme objet. Elles ont donc la mˆme r´f´rence et on peut ` ce moment e e ee autiliser indiff´remment p1 ou p2 pour agir sur l’objet consid´r´. Retenez donc e e eque affectation et construction ne sont pas la mˆme chose. e3.2.5 Comparaison de r´f´rence ee Dans le cas ou le programmeur n’aurait pas surcharg´ les op´rateurs == e eet != d’une classe, ces deux op´rateurs comparent deux r´f´rences. Ainsi, dans e eel’exemple pr´c´dent, p1 == p2 retournera un r´sultat positif. Il faut cependant e e efaire attention ` ne pas confondre comparer les r´f´rences avec comparer les a eevaleurs des objets. 12
  13. 13. 3.3 Utilisation La syntaxe pour manipuler les champs et m´thodes d’un objet suit le proto- etype suivant : [nom de l’objet].[nom de la m´thode ou du champ]. Par exemple, edans le cas de l’objet p1 de type Personne : p1.nom.3.3.1 Utilisation des champs Nous avions d´clar´ tous les champs comme private. Ce qui fait qu’` la e e acompilation, la moindre occurence du type p1.nom, p2.telephone, . . . se traduirapar une erreur de compilation pour violation du principe d’encapsulation. Unesolution serait de d´clarer ces champs comme public. Cepedant, nous avions eutiliser le terme private pour des raisons de s´curit´ et pour rendre le code e eplus fonctionnel. Pour acc´der aux champs, nous allons donc devoir utiliser les epropri´t´s qui ont pour m´rite d’expliciter la lecture et l’´criture 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 d´finition de m´thodes get au sein de ces propri´t´s permet de lire les e e eechamps et la d´finition de m´thodes set permet tout simplement de modifier la e evaleur de ces champs. Dans l’exemple pr´c´dent, l’absence de set aurait entrain´ e e eune erreur de compilation pour p.Age = 56 et l’absence de methode get auraitempˆch´ l’affichage sur la console. e e3.3.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 ede la mˆme fa¸on que des op´rateurs normaux. Il suffit de faire bien attention ` e c e aleur d´finition et ` leur fonctionnement et de les rendre le plus intuitifs possible. e aPar exemple, d´finir un op´rateur ¿ dans la cas de la classe Personne n’aurait e eaucun sens, alors qu’il en aurait un pour une classe Fraction. Concernant les m´thodes, elles s’utilisent de la mˆme fa¸on qu’une fonc- e e ction normale avec passage de param`tres et un type de sortie. Par exemple, la em´thode identifie sera utiliser de la fa¸on suivante : e cPersonne p = new Personne("Jean", "Michelin", 34, 0601020304);Console.WriteLine(p.Identifie()); La fonction WriteLine demande un param`tre string, fournit par la sortie de ela m´thode Identifie. e N´anmoins, il faut garder en m´moire que les m´thodes sont « appel´es » e e e epar un objet et font donc partie d’un ´cosyst`me particulier. e e3.4 Exemple Voici un exemple d’utilisation de la classe Personne : 13
  14. 14. 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 pr´voir ce que le programme va afficher dans la console. e4 H´ritage e4.1 Concepts L’h´ritage est une technique permettant de d´finir une classe ` partir d’une e e aclasse existente. Par exemple, ` partir de la classe Personne apportant d´j` les a eachamps nom, prenom, age, telephone ainsi que quelques propri´t´s et m´thodes, ee enous allons pouvoir d´finir d’autres classes dite classes-filles. Par exemple, si el’on veut mod´liser le fonctionnement d’une universit´, nous pourrons cr´er les e e eclasses ´tudiants, professeurs, personnels techniques,. . . ou pour mod´liser un e eavion de ligne, nous pourrons creer les classes pilotes, hˆtesses et passagers. Ce om´canisme est une sp´cialisation, ou une g´n´ralisation selon les cas, ` partir e e e e ad’une classe m`re regroupant leurs propri´t´s communes. e ee L’h´ritage est donc un m´canisme de r´utilisation du code ou seul les diff´rences e e e eentre les classes sont explicit´es. On parle alors de classe m`re et de classe fille. e e Une chose ` retenir en C#, l’h´ritage est dit : h´ritage simple car une classe a e efille ne peut peut avoir qu’une seule classe m`re (comme en Java) ` la diff´rence e a ed’autres languages comme le C++. Une derni`re chose permise par l’h´ritage est la red´finition de m´thodes e e e en’ayant pas le fonctionnement souhait´ dans la classse fille. La m´thode est e ealors red´finie pour adapter son comportement. e Voici la syntaxe pour d´clarer qu’une classe h´rite de la classe m`re Per- e e esonne :public class Passager : Personne{ 14
  15. 15. ...} C’est le symbole : qui permet d’expliciter que la classe Passager et l’h´riti`re e ede la classe Personne.4.2 Champs Une classe fille conserve l’ensemble des champs de la classe m`re mais peut en´anmoins ajouter d’autres champs. Par exemple, dans le cas d’un passager, on epourrait rajouter son num´ro de si`ge et le prix de son billet. e epublic class Passager : Personne{ //Champs private int siege; private double prix_billet;} Dans la cas d’un pilote, on pourra rajouter son nombre d’heures de vol ainsique son salaire.public class Pilote : Personne{ //Champs private int heures_vol; private double salaire;} Cependant, il faut faire attention ` l’application du principe d’encapsulation. aMˆme si les classes Passager et Pilote sont tr`s proches de la classe Personne, e ele fait que les champs d´finis dans Personne le soit avec le mot clef private eles oblige ` utiliser les propri´t´s pour y acc´der. Ce mode de fonctionnement a ee en’´tant pas tr`s pratique, il existe un autre mot clef permettant l’acc`s des e e echamps d’une classe ` ses classes filles : protected. Cela reviendrait ` d´finir la a a eclasse Personne de la mani`re suivante : epublic 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 edirectement, facilitant la programmation. Retenez surtout que protected permet l’acc`s au champs uniquement aux eclasses-filles de Personne, tandis que public autorise cet acc`s ` l’ensemble du e aprogramme et que private restraint cet acc`s aux m´thodes des objets de types e ePersonne. 15
  16. 16. 4.3 Constructeur Contrairement aux m´thodes, champs et propri´t´s, une classe fille n’h´rite e ee epas des constructeur de sa classe m`re. Les constructeurs doivent donc ˆtre e ered´finis. On peut cependant faire appel aux constructeurs de la classe m`re e edans un soucis de r´utilisation 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 l’appel par le mot clef base est absent, alors le compilateur va se tournervers un constructeur sans param`tre de Personne, (qui doit ˆtre pr´alablement e e ed´finis) et renverra une erreur si ce contructeur n’existe pas. e Retenez bien qu’un objet Passager est aussi une Personne et doit donc ˆtre einstanci´ comme une Personne avant de pouvoir ˆtre d´clarer comme un Passa- e e eger.4.4 M´thodes e Certaines m´thodes d’une classe m`re peuvent ne plus ˆtre adapt´e ` sa/ses e e e e aclasse(s) fille(s). Il faut alors red´finir la m´thode en question. e e Par exemple, la m´thode Identifie() de la classe Personne ne permet pas de erendre compte de l’ensemble des informations pr´sentes dans la classe Passager. eIl nous faut donc la compl´ter 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 l’utilisation du mot clef base de mani`re ` r´utiliser e a ela m´thode de la classe m`re. on pourrait tr`s bien se passer de l’utilisation de e e ece mot clef, l’essentiel ´tant que la m´thode Identifie soit adapt´e ` la classe On e e e aaurait tout aussi bien ´crire cette m´thode de la fa¸on 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 ` red´finir les op´rateurs si n´cessaire. a e e e 16
  17. 17. 4.5 Remarques compl´mentaires e La relation induite par l’h´ritage simple permet de constituer un arbre ed’h´ritage. Cet outil doit ˆtre consid´r´ comme une aide ` la conception d’un e e e e aprogramme permettant de hi´rarchiser ses classes et de voir si certaines peuvent efaire l’objet d’une classe m`re commune permettant un gain de temps certain eau niveau de la programmation. Une derni`re pr´cision concernant le vocabulaire : une classe fille est aussi e eappell´e une sous-classe et une classe m`re, une superclasse. e e4.6 Exemple Pour la classe m`re, reportez au code de la classe Personne d´finis ` la e e adeuxi`me section. Seul les champs d’instance sont d´clar´s comme protected e e eplutˆt que private. opublic 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; } //Propri´t´s e e public int Siege { get { return this.siege; } set { this.siege = value; } } public double Prix_Billet { get { return this.prix_billet; } 17
  18. 18. set { this.prix_billet = value; } } //Op´rateur 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; } //M´thode e public string Identifie() { string s = base.Identifie() + "," + this.siege + "," + this.prix_billet + ")"; return s; }}Litt´rature 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

×