Chapitre 9 L’Héritage

Sommaire Création de sous classes Spécificateur d’accès protected Référence super Surdéfinition des méthodes Hiérarchie des classes Classe object Classe abstraite Concevoir l’héritage

Création de sous classes – classes dérivées La notion d’héritage est un concept très important au niveau de la POO Il permet de définir (dériver) une nouvelle classe (B) à partir d’une classe existante (A) La classe existante (A) est appelée superclasse, classe parent ou bien classe de base La classe dérivée (B) est appelée sous classe ou classe enfant La sous classe hérite des propriétés de sa superclasse – données et méthodes La relation d’héritage est représentée ainsi (notation UML): Relation est-un

Création de sous classes – classes dérivées La relation est-un signifie que la sous classe est une forme (version) spécifique de la classe de base En plus d’hériter des propriétés de sa classe de base, la classe dérivée peut contenir de nouvelles méthodes, nouvelles variables ou bien modifier les propriétés héritées Le mécanisme d’héritage permet un meilleur partage, une meilleure réutilisabilité et permet également d’éviter la redondance - Gain en termes d’efforts relatifs à la conception, à l’implémentation et aux tests Pour établir une relation d’héritage entre deux classes, en Java, on utilise le mot clé extends: public class B extends A // la classe B dérive de la classe A { …….. }

//******************************************************************** // Words.java Author: Lewis/Loftus // // Demonstrates the use of an inherited method. public class Words { //----------------------------------------------------------------- // Instantiates a derived class and invokes its inherited and // local methods. public static void main(String[] args) Dictionary webster = new Dictionary(); System.out.println("Number of pages: " + webster.getPages()); System.out.println("Number of definitions: " + webster.getDefinitions()); System.out.println("Definitions per page: " + webster.computeRatio()); } VOIR EX41 Copyright © 2017 Pearson Education, Inc.

Output VOIR EX41 Number of pages: 1500 Number of definitions: 52500 Definitions per page: 35.0 //******************************************************************** // Words.java Author: Lewis/Loftus // // Demonstrates the use of an inherited method. public class Words { //----------------------------------------------------------------- // Instantiates a derived class and invokes its inherited and // local methods. public static void main(String[] args) Dictionary webster = new Dictionary(); System.out.println("Number of pages: " + webster.getPages()); System.out.println("Number of definitions: " + webster.getDefinitions()); System.out.println("Definitions per page: " + webster.computeRatio()); } VOIR EX41 Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Book.java Author: Lewis/Loftus // // Represents a book. Used as the parent of a derived class to // demonstrate inheritance. public class Book { protected int pages = 1500; //---------------------------------------------------------------- // Pages mutator. public void setPages(int numPages) pages = numPages; } // Pages accessor. public int getPages() return pages; Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Dictionary.java Author: Lewis/Loftus // // Represents a dictionary, which is a book. Used to demonstrate // inheritance. public class Dictionary extends Book { private int definitions = 52500; //----------------------------------------------------------------- // Prints a message using both local and inherited values. public double computeRatio() return (double) definitions/pages; } continue Copyright © 2017 Pearson Education, Inc.

//---------------------------------------------------------------- continue //---------------------------------------------------------------- // Definitions mutator. public void setDefinitions(int numDefinitions) { definitions = numDefinitions; } // Definitions accessor. public int getDefinitions() return definitions; Copyright © 2017 Pearson Education, Inc.

Spécificateur d’accès protected Outre les spécificateurs public, private, et de package (sans aucune mention) Java dispose d’un autre spécificateur lié au mécanisme d’héritage - protected Les propriétés précédées par le mot clé public sont visibles partout Les propriétés précédées par aucun spécificateur sont visibles au niveau du package Les propriétés précédées par le mot clé private sont locales à la classe Les propriétés précédées par le mot clé protected sont visibles à l’intérieur du package et au niveau des sous-classes Au niveau du diagramme UML, les variables et les méthodes protégées sont précédées par le symbole #

Diagramme de classes de Words Book # pages : int + pageMessage() : void Dictionary - definitions : int + definitionMessage() : void Words + main (args : String[]) : void Copyright © 2017 Pearson Education, Inc.

Référence super Le constructeur de la super classe ne peut être hérité ou utilisé directement par les objets de la sous classe Il arrive, cependant, que la construction d’un objet de la sous classe se base sur le constructeur de la super classe (super classe point avec abscisse et ordonnée et sous classe point coloré (spécifie une variable pour sa couleur pour construire un point coloré, on construit un point et on lui attribue une couleur)) Pour réutiliser le constructeur de la classe parent, on utilise la référence super – cela correspond à la première instruction du constructeur de la sous classe Cette instruction fait appel au constructeur de la super classe La référence super peut être également utilisée par la sous classe pour accéder aux variables ou aux méthodes définies au niveau de la super classe et visibles par la sous classe (par exemple, méthode afficher au niveau de point (affiche l’abscisse et l’ordonnée) et au niveau de point coloré, on redéfini une méthode afficher qui fait appel à celle de l’ancêtre super.Afficher(), on affiche après la couleur) on utilise le mot clé super pour préciser que la méthode appartient à la super classe et ne pas confondre avec les méthodes récursives)

//******************************************************************** // Words2.java Author: Lewis/Loftus // // Demonstrates the use of the super reference. public class Words2 { //----------------------------------------------------------------- // Instantiates a derived class and invokes its inherited and // local methods. public static void main(String[] args) Dictionary2 webster = new Dictionary2(1500, 52500); System.out.println("Number of pages: " + webster.getPages()); System.out.println("Number of definitions: " + webster.getDefinitions()); System.out.println("Definitions per page: " + webster.computeRatio()); } VOIR EX42 Copyright © 2017 Pearson Education, Inc.

Output VOIR EX42 Number of pages: 1500 Number of definitions: 52500 Definitions per page: 35.0 //******************************************************************** // Words2.java Author: Lewis/Loftus // // Demonstrates the use of the super reference. public class Words2 { //----------------------------------------------------------------- // Instantiates a derived class and invokes its inherited and // local methods. public static void main(String[] args) Dictionary2 webster = new Dictionary2(1500, 52500); System.out.println("Number of pages: " + webster.getPages()); System.out.println("Number of definitions: " + webster.getDefinitions()); System.out.println("Definitions per page: " + webster.computeRatio()); } VOIR EX42 Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Book2.java Author: Lewis/Loftus // // Represents a book. Used as the parent of a derived class to // demonstrate inheritance and the use of the super reference. public class Book2 { protected int pages; //---------------------------------------------------------------- // Constructor: Sets up the book with the specified number of // pages. public Book2(int numPages) pages = numPages; } continue Copyright © 2017 Pearson Education, Inc.

//---------------------------------------------------------------- continue //---------------------------------------------------------------- // Pages mutator. public void setPages(int numPages) { pages = numPages; } // Pages accessor. public int getPages() return pages; Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Dictionary2.java Author: Lewis/Loftus // // Represents a dictionary, which is a book. Used to demonstrate // the use of the super reference. public class Dictionary2 extends Book2 { private int definitions; //----------------------------------------------------------------- // Constructor: Sets up the dictionary with the specified number // of pages and definitions. public Dictionary2(int numPages, int numDefinitions) super(numPages); definitions = numDefinitions; } continue Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Prints a message using both local and inherited values. public double computeRatio() { return (double) definitions/pages; } //---------------------------------------------------------------- // Definitions mutator. public void setDefinitions(int numDefinitions) definitions = numDefinitions; // Definitions accessor. public int getDefinitions() return definitions; Copyright © 2017 Pearson Education, Inc.

Héritage multiple Héritage simple: une sous classe ne peut avoir qu’une super classe Héritage multiple: une sous classe peut avoir plusieurs super classes Héritage multiple: plusieurs propriétés peuvent être héritées à travers plusieurs chemins – collisions, complexité, difficultés de préserver la sémantique de la relation est–un Java supporte uniquement l’héritage simple – On arrive à résoudre tous les problèmes sans avoir recours à l’héritage multiple

Surdéfinition des méthodes Pour tenir compte des propriétés locales, spécifiques à la sous classe, il est parfois nécessaire de redéfinir une opération héritée L’opération redéfinie aura la même signature que la méthode de la super classe mais une implémentation différente qui tient compte des propriétés spécifiques de la sous classe Cette opération redéfinie effectue sur le plan sémantique le même travail que l’opération de la super classe Le choix de la méthode à exécuter dépendra du type d’objet référencé Seules les méthodes visibles par la sous classe peuvent être redéfinies Les méthodes déclarées final ne peuvent pas être redéfinies Une méthode static ne peut être redéfinie au niveau de la sous classe (car c’est le type de l’objet qui permet de sélectionner la méthode à exécuter)

//******************************************************************** // Messages.java Author: Lewis/Loftus // // Demonstrates the use of an overridden method. public class Messages { //----------------------------------------------------------------- // Creates two objects and invokes the message method in each. public static void main(String[] args) Thought parked = new Thought(); Advice dates = new Advice(); parked.message(); dates.message(); // overridden } Voir EX43 Copyright © 2017 Pearson Education, Inc.

Output I feel like I'm diagonally parked in a parallel universe. Warning: Dates in calendar are closer than they appear. //******************************************************************** // Messages.java Author: Lewis/Loftus // // Demonstrates the use of an overridden method. public class Messages { //----------------------------------------------------------------- // Creates two objects and invokes the message method in each. public static void main(String[] args) Thought parked = new Thought(); Advice dates = new Advice(); parked.message(); dates.message(); // overridden } Voir EX43 Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Thought.java Author: Lewis/Loftus // // Represents a stray thought. Used as the parent of a derived // class to demonstrate the use of an overridden method. public class Thought { //----------------------------------------------------------------- // Prints a message. public void message() System.out.println("I feel like I'm diagonally parked in a " + "parallel universe."); System.out.println(); } Voir EX43 Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Advice.java Author: Lewis/Loftus // // Represents some thoughtful advice. Used to demonstrate the use // of an overridden method. public class Advice extends Thought { //----------------------------------------------------------------- // Prints a message. This method overrides the parent's version. public void message() System.out.println("Warning: Dates in calendar are closer " + "than they appear."); System.out.println(); super.message(); // explicitly invokes the parent's version } Voir EX43 Copyright © 2017 Pearson Education, Inc.

Surdéfinition et Redéfinition Surdéfintion - N’est pas liée à la notion d’héritage - Plusieurs méthodes peuvent avoir le même non au sein d’une classe mais le nombre et/ou le type des arguments diffèrent - Toutes les méthodes peuvent être surdéfinies: constructeur, méthodes static ou méthodes d’instance Redéfintion - Liée à l’héritage - Une méthode redéfinie possède exactement la même signature que la méthode de la super classe - Seules les méthodes d’instance peuvent être redéfinies – celles précédées par le mot clé final ne peuvent pas l’être

Hiérarchie des classes Une classe B qui hérite d’une classe A peut être à son tour parent d’une classe C - on parle de hiérarchie de classes – voir exemple suivant Deux sous classes ayant la même super classes sont appelées classes sœurs Toutes les classes de la classe Animal sont appelées descendants de la classe – même chose pour la classe Reptile, Bird et Mammal Au niveau des super classes, on met les propriétés communes à l’ensemble des sous classes – ainsi, au niveau d’Animal on met ce qui est commun à l’ensemble des sous classes Reptil, Bird et Mammal Au niveau de Reptil, on met ce qui est commun à Snake et Lizard, etc. Une propriété définie au niveau d’une super classe (Animal) est héritée à travers les différents chemins menant aux différentes sous classes En fonction du contexte, différentes hiérarchies peuvent être établies

Copyright © 2017 Pearson Education, Inc.

Classe objet Exemple : System.out. Println(“a= “ = a.toString()); La classe Object est définie au niveau du package java.lang de la librairie des classes standards Java Toutes les classes dérivent implicitement de la classe Object – autrement dit, si une classe A ne dérive pas explicitement d’une classe via la relation extends, cette classe A est une sous classe de la classe Object La classe Object est la classe racine (mère) de toutes les hiérarchies de classes La classe Object dispose de quelques méthodes qu’on peut utiliser directement ou bien redéfinir: toString et equals La méthode toString de la classe Object fournit une chaîne de caractère contenant le nom de la classe concernée et l’adresse de l’objet précédé par @ Exemple : System.out. Println(“a= “ = a.toString()); a= Point@c12aedf // résultat

Classe Object La méthode equals définie au niveau de la classe Object permet de comparer les références des objets concernés Exemple :Object a1 =new point (1,20); Object a2 =new point (11,22); a1.equals(a2); // renvoie false – méthode utilisée est celle de Object Il est possible de redéfinir les méthodes dans n’importe quelle classe – la classe String redéfinie la méthode equals pour comparer deux chaînes de caractères

Classe Abstraite Une classe abstraite ne permet pas d’instancier des objets Elle regroupe un certain nombre de propriétés communes à ses descendants Elle fournit le cadre contractuel à ses descendants Une classe abstraite est précédée par le mot clé abstract public abstract class Product { // contenu de la classe …….} Dans une classe abstraite, on définit souvent: - des méthodes abstraites - juste la signature de la méthode précédée par le mot clé abstract – ces méthodes doivent être publiques et doivent être définies par les descendants de la classe en question - des méthodes non abstraites - avec leurs définitions complètes – la classe abstraite peut ne pas contenir de méthodes abstraites - une méthode abstraite ne peut être déclarée comme static ou final Lorsque les méthodes abstraites ne sont pas définies pas la sous classe, celle-ci est considérée comme abstraite.

Hiérarchie des interfaces La notion d’héritage peut être également appliquée aux interfaces Une interface I1 peut être dérivée d’une autre interface I0 L’interface I1 hérite de l’ensemble des propriétés de l’interface I0 – méthodes abstraites Une classe implémentant une interface I doit définir l’ensemble des méthodes définies au niveau de celle-ci Une classe hérite d’une seule classe mais peut implémenter plusieurs interfaces Les hiérarchies des interfaces et celles des classes sont distincts

//******************************************************************** // FoodAnalyzer.java Author: Lewis/Loftus // // Demonstrates indirect access to inherited private members. public class FoodAnalyzer { //----------------------------------------------------------------- // Instantiates a Pizza object and prints its calories per // serving. public static void main(String[] args) Pizza special = new Pizza(275); System.out.println("Calories per serving: " + special.caloriesPerServing()); } VOIR EX45

//******************************************************************** // FoodItem.java Author: Lewis/Loftus // // Represents an item of food. Used as the parent of a derived class // to demonstrate indirect referencing. public class FoodItem { final private int CALORIES_PER_GRAM = 9; private int fatGrams; protected int servings; //----------------------------------------------------------------- // Sets up this food item with the specified number of fat grams // and number of servings. public FoodItem(int numFatGrams, int numServings) fatGrams = numFatGrams; servings = numServings; } continue VOIR EX45 Copyright © 2017 Pearson Education, Inc.

continue //----------------------------------------------------------------- // Computes and returns the number of calories in this food item // due to fat. private int calories() { return fatGrams * CALORIES_PER_GRAM; } // Computes and returns the number of fat calories per serving. public int caloriesPerServing() return (calories() / servings); VOIR EX45 Copyright © 2017 Pearson Education, Inc.

Output VOIR EX45 Calories per serving: 309 //******************************************************************** // FoodAnalyzer.java Author: Lewis/Loftus // // Demonstrates indirect access to inherited private members. public class FoodAnalyzer { //----------------------------------------------------------------- // Instantiates a Pizza object and prints its calories per // serving. public static void main(String[] args) Pizza special = new Pizza(275); System.out.println("Calories per serving: " + special.caloriesPerServing()); } VOIR EX45 Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Pizza.java Author: Lewis/Loftus // // Represents a pizza, which is a food item. Used to demonstrate // indirect referencing through inheritance. public class Pizza extends FoodItem { //----------------------------------------------------------------- // Sets up a pizza with the specified amount of fat (assumes // eight servings). public Pizza(int fatGrams) super(fatGrams, 8); } VOIR EX45 Copyright © 2017 Pearson Education, Inc.

Concevoir l’héritage L’héritage est un concept très important dans le paradigme objet Pour tirer profits et bénéfices de ce concept en termes de maintenance, de réutilisation, de partage et de non redondance, il faut l’utiliser en respectant certaines règles: - La relation est-un doit être préservée entre une super classe et l’ensemble de ses sous classes - Mettre les propriétés communes au niveau des super classes et les propriétés spécifiques au niveau de chacune des sous classes - Redéfinir certaines méthodes héritées pour prendre en charge les propriétés spécifiques des sous classes et rajouter de nouvelles variables s’il y a lieu - Permettre à chacune des classes de gérer ses propres données et utiliser la référence super pour invoquer le constructeur parent pour compléter la construction de l’objet

Concevoir l’héritage - Utiliser la notion de classe abstraite pour augmenter le potentiel de réutilisation au niveau des sous classes (en termes de signatures de méthodes – même interface) – les méthodes déclarées au niveau de la classe abstraite vont avoir la même interface au niveau des sous classes - Utiliser les spécificateurs d’accès avec beaucoup d’attention pour préserver l’encapsulation et réduire l’impact des modifications - Une classe déclarée final ne peut être dérivée - une méthode déclarée final ne peut–être redéfinie - Une classe abstraite ne peut-être déclarée final