CSI 1502 Principes fondamentaux en conception des logiciels

CSI 1502 Principes fondamentaux en conception des logiciels Chapitre 7: L‘héritage

Objectifs du cours: L‘héritage n n Une autre technique OO fondamentale dénommé l`héritage, pour organiser et créer des classes et promouvoir leur réutilisation. Comprendre ce qui suit: n Dériver de nouvelles classes de classes existantes n Créer des hiérarchies de classe: une classe parent et de classes enfants n Le modificateur d`accès protected n Le Polymorphisme via l`héritage n Hiérarchies héréditaires pour les interface 2

Qu`est-ce qu`est l`héritage? n n L`héritage permet au programmeur de dériver de nouvelles classes à partir de classe existante. La classe existante est dénommé la classe parent, ou super classe (superclass) ou classe de base (base class). La classe dérivé est dénommé classe enfant ou sousclasse (subclass) Comme le nom indique, l`enfant hérite des caractéristiques de la classe parent. n C`est à dire que la classe enfant hérite: n Des méthodes et données définis dans la classe parent 3

L`héritage : Idée principale n n Afin d`ajuster la classe dérivée un programmeur peut: n Ajouter de nouvelles variables ou méthodes, ou n Modifier les éléments hérités La réutilisant de logiciel est au coeur de l`héritage n En utilisant des objets logiciels existants afin de créer d`autres objets logiciels, nous bénéficions de tout le travail qui à été mis dans la création, implémentation et vérification des logiciels existants. 4

Visualisation de l`héritage n Les relations héritage sont souvent montrées de façon graphiques dans les diagramme de classe, avec une flèche allant vers la classe parent Vehicle Car L`héritage crée une relation «est un(e)» (is-a), soit que l`enfant est une version plus spécifique le parent 5

Dérivation de sous classes n En Java, le mot réservé extends est utilisé pour établir une relation d`héritage class Car extends Vehicle { // class contents } n Voir Words. java, Book. java et Dictionary. java (pp. 384++) 6

Diagramme UML montrant l`héritage Words + main (args : String[]) : void Dictionary - definition: int + definition. Message( ): void Book # pages: int + page. Message( ): void 7

Programme pilote: Words. java public class Words { //Instansiates a derived class public static void main (String[] args) { Dictionary webster= new Dictionary(); webster. page. Message(); webster. definition. Message(); } } 8

Book. java: La Classe Parent public class Words { //Instansiates a derived class public static void main (String[] args) { Dictionary webster= new Dictionary(); } } webster. page. Message(); webster. definition. Message(); 9

Dictionary. java: La classe enfant public class Dictionary extends Book { private int definitions = 52500; public void definition. Message() { System. out. println("Number of definitions: " + definitions); System. out. println("Definitions per page: " + definitions/pages); } } Number of pages: 1000 Number of definitions: 52500 Definitions per page: 52 10

Modificateur d`accès: Le modificateur protected n n Les modificateurs d`accès déterminent quels membres de la classe sont héritable et lesquels ne le sont pas Les variables et méthodes déclarées avec un modificateur public sont héritées; ceux avec un modificateur private ne le sont pas Mais le variables public violent le principe d`encapsulation Il existe un troisième modificateur d`accès qui aide les situation d`héritage: protected 11

Le modificateur protected n n Le modificateur d`accès protected permet à un membre de la classe parent a être hérité par l`enfant Le modificateur protected donne une meilleure encapsulation que le modificateur public. Malgré ça, le modificateur protected n`a pas une encapsulation plus forte que le modificateur private Plus de détails sure chaque modificateur est donné dans l`appendice F. 12

Référence à un parent: La référence super n n Les constructeurs ne sont pas héritables, malgré leur modificateur public Et pourtant souvent nous voudrions utiliser le constructeur de la classe parent afin d`initialiser la «partie du parent» dans l`objet La référence super peut-être utilisée pour invoquer la classe parent, et souvent est utilisé pour invoquer le constructeur de celui-ci Voir l`exemple Word 2, pp. 388 -393 13

Le programme pilote: Words 2. java public class Words 2 { //Instansiates a derived class public static void main (String[] args) { Dictionary 2 webster= new Dictionary 2(1500, 52500); webster. page. Message(); webster. definition. Message(); } } Number of pages: 1500 Number of definitions: 52500 Definitions per page: 35 14

La classe parent: Book 2. java public class Book 2 { protected int pages; public Book 2(int num. Pages) { pages = num. Pages; } // print a message public void page. Message() { System. out. println("Number of pages: " + pages); } } 15

La classe enfant: Dictionary 2. java public class Dictionary 2 extends Book 2 { private int definitions; public Dictionary 2(int num. Pages, int num. Definitions) { super(num. Pages); definitions = num. Definitions; } public void definition. Message() { System. out. println("Number of definitions: " + definitions); System. out. println("Definitions per page: “ + definitions/pages); } } 16

Plus au sujet de la référence super n n n Un constructeur d`une classe enfant et responsable d`appeler le constructeur du parent La première ligne du constructeur doit utiliser la référence super afin d`appeler le constructeur du parent La référence super peut aussi être utilisé afin d`accéder à d`autres variables et méthodes définies dans la classe parent 17

L`héritage simple vs. l`héritage multiple n n Java ne supporte que l`héritage simple, soit qu`une classe dérivé ne peut n`avoir qu`un seul parent! Certains autre langages supportent l`héritage multiple, ce qui permet à certaines classes d`être dérivées de plusieurs classe bénéficiant de toutes les variables et méthodes de ses parent n Ceci implique les collisions, tel que d`avoir deux variables du même nom doivent alors être résolues n Dans la plus part des cas, l`utilisation d`interface nous donne les avantages de l`héritage multiple sans la complexité 18

L`outrepassement de méthodes n Une classe enfant peut outrepasser la définition d`une méthode hérité en faveur de sa propre méthode n n n C`est à dire, que un enfant peut redéfinir une méthode héritée de son parent La nouvelle méthode doit avoir la même signature que la méthode du parent, mais peut avoir un fonctionnalité différente. Le type de l`objet en train d`exécuter détermine quel version de la méthode qui doit être invoquée 19

L`outrepassement de méthodes : Messages. java (p. 392) public class Messages { public static void main (String[] args) { Thought parked = new Thought(); Advice dates = new Advice(); } } parked. message(); dates. message(); I feel fine Warning: Time is shrinking 20

Thought. java public class Thought { public void message() { System. out. println("I feel fine"); System. out. println(); } } 21

Advice. java public class Advice { public void message() { System. out. println("Warning: Time is shrinking"); System. out. println(); } } public class Advice extends Thought { public void message() { System. out. println("Warning: Time is shrinking"); System. out. println(); }} super. message(); 22

L`outrepassement de méthodes et de variables n n n Notez que la méthode parent peut être invoqué spécifiquement en utilisant la référence super Si une méthode est déclaré avec le modificateur final, on ne peut l`outrepasser Le concept d`outrepassement peut aussi être appliqué au variables (dénommé shadowing variables en anglais). Mais ceci, de règle générale, est non recommandé 23

La surcharge de méthodes vs. l`outrepassement de méthodes n n La surcharge de méthodes concerne plusieurs méthodes dans une même classe ayant le même nom mais pas la même signature. L`outrepassement de méthodes concerne deux méthodes l`une dans une classe parent l`autre dans la classe enfant ayant le même nom et la même signature. La surcharge de méthodes vous permet de définir des opérations similaires de façon différentes pour différentiels type de données L`outrepassement de méthodes vous permet de définir une opération similaire de façon différente pour des objets différents. 24

Hiérarchies de classe n Une classe enfant d`un parent peut-être le parent d`une autre classe enfant, créant ainsi une Hiérarchies de classe Business Retail. Business KMart Macys Service. Business Kinkos 25

Hiérarchies de classe: Quelques définitions n n n Deux enfants du même parents sont dénommé «siblings» Un bon concept est de mettre les aspects commun aussi haut que raisonnable dans une hiérarchie Un membre héritable se fait passer dans tous les enfants n Le mécanisme d`héritage est transitif C`est à dire que une classe enfant hérite de tous ces ancêtres Il n`existe pas «La» hiérarchie de classe qui est appropriée dans toutes les situations Les hiérarchies de classes doivent souvent être modifiées et améliorées afin de rester utile 26

La classe Object: Incluse dans java. lang n n Toutes les classes sont dérivées de la classe Object La classe Object est l`ultime parent de toute les hiérarchies de classe La classe Object contient quelques méthodes utiles qui sont hérité par toutes les classes Par exemple, la méthode to. String est définie dans la classe Object n C`est pourquoi la méthode println peut appeler to. String pour tous les objets qui lui est passé – tous les objets sont garantis d`avoir une méthode to. String par l`héritage 27

Classes Abstraites n n n Une classe abstraite est une classe qui représente un concept générique dans une hiérarchie Une classe abstraite ne peut-être utilisé Nous utilisons le modificateur abstract sur la l`entête de la classe pour déclarer une classe abstraite abstract public class vehicle 28

Que sont les Classes Abstraites? n n Une classe abstraite contient souvent des méthodes sans définitions (comme les interfaces), mais ce n`est pas obligatoire Contrairement à une interface, le modificateur abstract peut-être appliqué à chaque méthode abstraite Une classe abstraite contient typiquement des méthodes non abstraites avec des méthodes fonctionnelles, faisant la différence entre les classes abstraites et les interfaces Une classe déclaré abstraite ne doit pas nécessairement contenir des méthodes abstraites. 29

Que sont les Classes Abstraites? n n n L`enfant d`une classe abstraite doit outrepasser les méthodes abstraites du parent, sinon l`enfant va aussi devenir avstrait Une méthode abstraite ne peut être définie comme n final (car la méthode doit être outrepassée) n static (car la méthode n`est pas définie) L`utilisation d`une classe abstraite est une décision de concept; cela permet de créer des éléments communs dans une classe trop générale pour être utile. Par exemple n n Vehicle, Fuel. Consumption Employee, Benefits. Calculation 30

Utilisation indirecte de membres d`une classe: Références et héritage n n Un objet référé peut faire référence à un objet de sa classe, ou à un objet de n`importe quel autre classe relié par héritage Par exemple, si la classe Holiday est utilisé pour dériver un enfant dénommé Christmas, alors une référence Holiday peut-être utilisé pour pointer sur un objet Christmas Holiday day; day = new Christmas(); 31

Références et héritage : Ouverture vs fermeture n n Conversion d`ouverture ( «Widening conversion» ): n Assigner un objet prédécesseur à une référence d`ancêtre n Fait par une simple assignation Conversion de fermeture ( «Narrowing conversion» ): n Assigner un objet d`ancêtre prédécesseur à une référence de prédécesseur n Fait par un conversion ( «cast» ) 32

Utilisation indirecte de membres non hérités n n n Un membre hérité peut être référencé directement par nom dans la classe enfant, tout comme si il y fût déclaré Mais, même si une méthode ou variable n`est pas hérité par l`enfant, on peut encore y accéder au travers des méthodes du parent Voir Food. Analysis. java (page 403) Voir Food. Item. java (page 404) Voir Pizza. java (page 405) 33

Food. Analysis. java public class Food. Analysis { public static void main (String[] args) { Pizza special = new Pizza(275); } } System. out. println("Calories per serving: " + special. calories. Per. Serving()); Calories per serving: 309 34

Food. Item. java public class Food. Item { final private int CAL_PER_GRAM = 9; private int fat. Grams; protected int servings; public Food. Item(int num. Fat. Grams, int num. Servings) { fat. Grams = num. Fat. Grams; servings = num. Servings; } private int calories() { return fat. Grams*CAL_PER_GRAM; } } public int calories. Per. Serving() { return (calories()/servings); } 35

Pizza. java public class Pizza extends Food. Item { public Pizza(int fat. Grams) { super(fat. Grams, 8); } } 36

Polymorphisme: Avoir plusieurs formes n n Une référence peut être polymorphique, ce qui peut être défini comme «avoir plusieurs formes» n Une variable référencé polymorphique peut référer à différent types d`objets durant l`exécution n Les références polymorphiques sont résolues durant l`exécution; ceci est dénommé «dynamic binding» L`utilisation prudente de références polymorphiques permet de construire des logiciels élégant et robustes. Mammal pet; Horse myhorse = new Horse(); // Horse derived from Mammal // Horse is-a Mammal pet = myhorse; 37

Polymorphisme via héritage n n Supposons que la classe Holiday à une méthode dénommé celebrate, et que la classe Christmas l`outrepasse Considérons maintenant l`invocation suivante: day. celebrate(); n Si day référe à un objet Holiday, il invoce la version celebrate de Holiday; de même pour l`objet Christmas 38

Polymorphisme via héritage n Considérons la hiérarchie de classe suivante: Staff. Member Volunteer Employee Executive Hourly • Considérons maintenant la tâche de payer tous les employés 39

Firm. java public class Firm { public static void main (String[] args) { Staff personnel = new Staff(); personnel. payday(); } } Name: Sam Phone: 555 -3456 Paid: 3341. 07 Name: Joe Phone: 555 -1432 Paid: 1000. 0 Name: Sue Phone: 555 -6567 Thanks! Name: Ann Phone: 555 -7876 40

Staff. java public class Staff { private Staff. Member[] staff. List; public Staff() { staff. List = new Staff. Member[4]; } staff. List[0] staff. List[1] staff. List[2] staff. List[3] = = new new Executive("Sam", "555 -3456", 2341. 07); Employee("Joe", "555 -1432", 1000. 00); Volunteer("Sue", "555 -6567"); Volunteer("Ann", "555 -7876"); Continued… 41

Staff. java (cont. ) … public void payday() { double amount; } } for (int count = 0; count < staff. List. length; count++) { System. out. println(staff. List[count]); amount = staff. List[count]. pay(); if (amount == 0) System. out. println("Thanks!"); else System. out. println("Paid: " + amount); } 42

Staff. Member. java abstract public class Staff. Member { protected String name; protected String phone; public Staff. Member(String e. Name, String e. Phone) { name = e. Name; phone = e. Phone; } public String to. String() { String result = "Name: " + name + "n"; result += "Phone: " + phone; } return result; public abstract double pay(); } 43

Volunteer. java public class Volunteer extends Staff. Member { public Volunteer (String e. Name, String e. Phone) { super(e. Name, e. Phone); } } public double pay() { return 0. 0; } 44

Employee. java public class Employee extends Staff. Member { protected double pay. Rate; public Employee(String e. Name, String e. Phone, double rate) { super(e. Name, e. Phone); pay. Rate = rate; } public double pay() { return pay. Rate; } public String to. String() { String result = super. to. String(); } } return result; 45

Executive. java public class Executive extends Employee { private double bonus; public Executive(String e. Name, String e. Phone, double rate) { super(e. Name, e. Phone, rate); bonus = 1000; } public double pay() { double payment = super. pay() + bonus; } } return payment; 46

Hiérarchies d`interface n n n L`héritage peut-être appliqué aux interfaces aussi bien qu`aux classes Une interface peut-être dérivé d`une autre interface L`interface enfant hérite toutes les méthodes abstraites du parent Une classe implémentant l`interface enfant doit définir toutes les méthodes de l`interface du parent ainsi que ceux de l`enfants Tous les membres d`une interface sont public Notez que les hiérarchies de classes et hiérarchies d`interface sont distinctes 47

Polymorphisme via Interfaces n n Un nom d`interface peut-être utilisé pour déclarer une variable d`objet référence Les interfaces permettent des références polymorphiques dans lesquelles n la méthode qui se fait invoquer est determiné par l`objet référencé 48

Speakers, Philosophers and Dogs public interface Speaker { public void speak(); public void announce (String str); } Assumons les classes Philosopher et Dog sont implementé en utilisant l`interface Speaker: Speaker guest; guest = new Philosopher(); guest. speak(); speak method dans la classe Philosopher guest = new Dog(); guest. speak; speak method dans la classe Dog 49

Héritage et GUIs: Plus à ce sujet dans le Chapitre 9 n n Un applet est un excellent exemple d`héritage Rappelons nous que lors de la définition d`un applet, on étend la classe Applet ou la classe JApplet Les classes Applet et JApplet s`occupent de tous les détails pour la création et l`exécution d`un applet, incluant les interactions avec le fureteur Quand nous définissons certaines méthodes, tel que paint d`un applet, en effet nous outrepassons la méthode définie dans la classe Component, qui est ultimement hérité dans les Applet ou JApplet 50

Sommaire: Chapitre 7 n Comprendre ce qui suit: n Dériver de nouvelles classes de classes existantes n Créer des hiérarchies de classe: une classe parent et de classes enfants n Le modificateur d`accès protected n n Le Polymorphisme via l`héritage Hiérarchies héréditaires pour les interface 51