Héritage H. Batatia

plan Notion (que signifie l’héritage) Ecriture en java Héritage multiple (interdit) Instanciation (partie propre et partie héritée) Constructeur (super() et super) Réécriture de méthode (réutilisation, enchainement de code) Méthode abstraite (abstract, obligation d’écriture) Classe abstraite (au moins une méthode abstraite) Interface (toutes les méthodes abstraites) Transtypage d’objet (sur-cast et sous-cast) Polymorphisme (détermination des méthodes appelées à l’exécution) Héritage avec Object Comparaison d’objets (equals) instanceOf Class, getClass Clonage, toString

Introduction L'approche orientée objet apporte le principe de la réutilisabilité Dans Java, ce principe est matérialisé par le mécanisme de l'héritage Une classe peut hériter des variables et méthodes d'une autre classe –elle peut en remplacer certaines En exemple, considérons le cas suivant

Cas On souhaite écrire un simulateur de course de véhicules, contenant des Voitures, des Motos, des Coupés et des Véhicules bridés Chaque véhicule se caractérise entre autre par –marque, modèle, plaque minéralogique, année, vitesse, vitesse maximale, nombre de places, nombre de roues –et éventuellement nombres de portes Ecrivons d'abord les classes Voiture et Moto

Voiture public class Voiture1 { private String plaque; private double vitesse; private double maxVitesse; private String marque; private String modèle; private int année; private int nombrePlaces; private int nombreRoues = 4; private int nombrePortes; // constructeurs public Voiture1 (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces, int numberPortes) ; public Voiture1 (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) ; public Voiture1 (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces, int nombrePortes) ; // getters public String getPlaque() ; public String getMarque() ; public String getModèle() ; public int getAnnée() ; public int getNombrePlaces() ; public int getNombreRoues() ; public int getNombrePortes() ; public double getMaxVitesse() ; public double getVitesse() ; // setter public void setPlaque(String plaque) ; // accélérer à max public void àFond() ; public void accélérer (double gamma, double temps) ; }

Une autre classe Maintenant, considérons la classe Moto Elle aura aussi une marque, un modèle, une année, une vitesse, une vitesse maximale, un nombre de place, un nombre de roues, etc… Examinons cette classe

Moto public class Moto1 { private String plaque; private double vitesse; private double maxVitesse; private String marque; private String modèle; private int année; private int nombrePlaces; private int nombreRoues = 2; // constructeurs public Moto1 (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) ; public Moto1 (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) ; // getters public String getPlaque() ; public String getMarque() ; public String getModèle() ; public int getAnnée() ; public int getNombrePlaces() ; public int getNombreRoues() ; public double getMaxVitesse() ; public double getVitesse() ; // setter public void setPlaque(String plaque) ; // accélérer à max public void àFond() ; public void accélérer (double gamma, double temps) ; }

Comparer Voiture1 et Moto1 On remarque qu'il y a beaucoup de choses identiques Les seules différences concernent –les constructeurs, –une variable et –une méthode L'héritage exploite la redondance dans les classes Construisons une super-classe nommée VéhiculeMotorisé –mettons y tout ce qui est commun à Voiture1 et Moto1 –nous omettons les variables nombreRoues (spécifique au type de véhicule) et nombrePortes (inexistant dans certains types de véhicules)

VéhiculeMotorisé public class VéhiculeMotorisé { protected String plaque; protected double vitesse; protected double maxVitesse; protected String marque; protected String modèle; protected int année; protected int nombrePlaces; // constructeurs public VéhiculeMotorisé (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) ; public VéhiculeMotorisé (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) ; // getters public String getPlaque() ; public String getMarque() ; public String getModèle() ; public int getAnnée() ; public int getNombrePlaces() ; public double getMaxVitesse() ; public double getVitesse() ; // setter protected void setPlaque(String plaque) ; // accélérer à max public void àFond() ; public void accélérer (double gamma, double temps) ; }

Héritage On peut maintenant redéfinir les deux classes Moto et Voiture par héritage de la classe VéhiculeMotorisé

Nouvelle Moto public class Moto extends VéhiculeMotorisé { private int nombreRoues = 2; public Moto (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) { this (plaque, 0.0, maxVitesse, marque, modèle, année, nombrePlaces); } public Moto (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) { super (plaque, vitesse, maxVitesse, marque, modèle, année, nombrePlaces); } public int getNombreRoues() { return this.nombreRoues; }

Nouvelle Voiture public class Voiture extends VéhiculeMotorisé { private int nombreRoues = 4; private int nombrePortes; public Voiture (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces, int nombrePortes) { this (plaque, 0.0, maxVitesse, marque, modèle, année, nombrePlaces, nombrePortes); } public Voiture (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) { this (plaque, vitesse, maxVitesse, marque, modèle, année, nombrePlaces, 4); } public Voiture (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces, int nombrePortes) { super (plaque, vitesse, maxVitesse, marque, modèle, année, nombrePlaces); this.nombrePortes = nombrePortes; } public int getNombreRoues() { return this.nombreRoues; } public int getNombrePortes() { return this.nombrePortes; }

super super() est le constructeur de la super-classe Elle est utilisée dans les constructeurs de la sous-classe class B extends A { public B ( ) { super ( ) ; // équivalent de A ( ) ; } on utilise super() pour initialiser les variables héritées super() doit être la première ligne du constructeur super est aussi la référence vers le parent –super.m () appelle la méthode m() de la classe parent

Exercice Ecrire une classe TestVéhicule qui génère 10 voitures et 10 motos aléatoirement et qui affiche leurs états. Vous pouvez au besoin modifier les classes VéhiculeMotorisé, Voiture et Moto

Héritage à plusieurs niveaux Dans l'exemple précédent, Voiture hérite de VéhiculeMotorisé –c'est un héritage à un niveau Il n'y a pas de limite aux niveaux d'héritage –on peut créer une classe Coupé qui hérite de Voiture –Coupé hérite de Voiture et de VéhiculeMotorisé En pratique, on ne dépasse pas un héritage de niveau 5 ou 6 pour éviter la complexité du code

La classe Coupé public class Coupé extends Voiture { public Coupé (String plaque, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) { this(plaque, 0.0, maxVitesse, marque, modèle, année, nombrePlaces); } public Coupé (String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces) { super (plaque, vitesse, maxVitesse, marque, modèle, année, nombrePlaces, 2); }

Réécriture de méthode Supposons, une fois le développement avancé, que nous souhaitons limiter la vitesse à 130 km/h Trois solutions –rééditer le fichier Voiture.java et modifier le code la classe voiture étant utilisée ailleurs cela risque de créer des problèmes –créer une nouvelle classe à zéro cela duplique beaucoup de code de Voiture. La maintenance doit se faire sur les deux classes –créer une classe qui hérite de Voiture et réécrire la méthode accélérer c'est cette solution que nous adopterons

La classe VoitureBridée public class VoitureBridée extends Voiture { private static final double vitesseLimite = 130.0; //km par h public VoitureBridée(String plaque, double vitesse, double maxVitesse, String marque, String modèle, int année, int nombrePlaces, int nombrePortes) { super(plaque, vitesse, maxVitesse, marque, modèle, année, nombrePlaces, nombrePortes); if (vitesse > vitesseLimite) this.vitesse = vitesseLimite; } public void accélérer (double gamma, double temps) { double vitesse = this.getVitesse() + gamma * temps; if (vitesse > vitesseLimite) { this.àFond(); } else { super.accélérer(gamma, temps); } public void àFond(){ this.vitesse = vitesseLimite; }

Exercices Réécrire la méthode àFond() dans la classe VoitureBridée Modifier TestVéhicule pour faire un simulateur qui accélère aléatoirement les véhicules et affiche leurs vitesses et leurs distances parcourues

Ajout de méthodes Une sous-classe n'est pas restreinte aux méthodes de la super-classe Elle peut ajouter de nouvelles méthodes

Classe finale Une classe finale ne peut pas être utilisée pour l'héritage

Exemple final class A { String nom; public A (String s){ nom = s; } class B extends A { //interdit par le compilateur public B (String s){ super(s); }

Méthode "finale" Une méthode finale ne peut pas être réécrite en cas d'héritage

Exemple class A { String nom; public A (String s){ nom = s; } public final int valeurEntière(){ return this.nom.hashCode(); } class B extends A { //interdit par le compilateur public B (String s){ super(s); } public int valeurEntière() { //interdit par le compilateur return 2 * this.nom.hashCode(); }

Classe abstraite Une classe peut être déclarée abstraite en précédant son nom du terme abstract Une classe abstraite ne peut pas être instantiée Exemple : la classe VéhiculeMotorisé peut être abstraite

Exemple abstract class A { String nom; A ( String s) { nom = s;} } class B { public static void main(String [] args){ A var = new A( args[0] ) ; //interdit … }

Méthode abstraite Une méthode abstraite est précédée du terme abstract Elle n'a pas de code Elle fait partie d'une classe abstraite Une sous-classe d'une classe abstraite doit implanter toutes ses méthodes abstraites Exemple, on peut doter la classe VéhiculeMotorisé de la méthode public abstract String carburant (); Celle-ci peut être implantée différemment par les classes Moto, Voiture et autres

Exemple abstract class A { public abstract String carburant(); } class B extends A { public String carburant(){ return "Diesel"; }

Héritage multiple Certains langages permettent à une classe d'hériter de plusieurs classes Cela n'est pas le cas dans JAVA La solution adoptée est la notion d'interface

Interface Une interface est une classe ne contenant que des méthodes abstraites, des variables final et static Sa particularité est quelle peut être ajoutée à n'importe quelle classe –y compris celle qui hérite d'une classe tierce

Exemple public interface Devise { static final float TAUX = ; public float euros (); }

Implémenter une interface Pour utiliser une interface, une classe doit l'implémenter en utilisant le terme implements L'implantation d'une interface permet d'écrire ses méthodes

Exemple class A { String nom; A ( String s) { nom = s;} public String toString(){ return nom;} } class B extends A implements Devise { float prix; B ( String s) { super( s ); } public static void main(String [] args){ B var = new B( args[0] ) ; System.out.println( var); } public float euros () { return TAUX * prix; } public interface Devise { static final float TAUX = ; public float euros (); }

Interface JAVA Il existe de nombreuses interfaces prédéfinies dans JAVA –Cloneable permettant de cloner un objet clone() de Object –Comparable contenant la méthode compareTo() permettant de comparer deux objets –Serialisable permettant d'écrire un objet dans un fichier –Runnable permettant d'indiquer que les objets seront exécutés comme des threads

Exemple class A { String nom; A ( String s) { nom = s;} public String getNom(){ return nom;} } class B extends A implements Cloneable { float prix; B ( String s) { super( s ); } public static void main(String [] args) throws Exception { B u = new B( args[0] ) ; System.out.println( u + " : Nom = " + u.getNom()); B v = (B) u.clone(); System.out.println(v + " : Nom = " + v.getNom()); }

Copie d'un tableau import es.*; class Copie { public static void main(String [] args){ String [] s = (String []) args.clone(); for(int i = 0; i<s.length; i++) System.out.println(s[i]); int [] t = {1, 2, 3, 4, 5, 6}; int [] c = (int []) t.clone(); for(int i = 0; i<c.length; i++) System.out.println(c[i]); }

Exercice Ecrire les classes permettant de manipuler des formes géométriques et calculer leurs périmètres –class Sommet –interface Longueur { public double périmètre(); } –abstract class Forme –class Quadrilatère extends Forme implements Longueur –class Rectangle extends Quadrilatère implements Longueur Ecrire une classe Test qui crée aléatoirement des formes dont on imprime le type, les sommets et le périmètre –la forme est aléatoire et les sommets sont aussi aléatoires

Classe interne Une classe interne est une classe dont le code est totalement écrit dans une autre classe Elle ne peut pas contenir de membre statique Ce genre de classe est un attribut de la classe container –elle peut être public, private, protected, final abstract Une classe interne B, définie dans A, est prévue pour être utilisée dans la classe B et ses sous classe Cependant (au besoin) on peut aussi l'utiliser dans d'autres classes –pour cela, on utilise la référence A.B La classe B a accès à tous les attributs de A même s'ils sont private

Exemple class MaListe { Elément tête; void supprimerTête( ); void supprimerQueue ( ); int rechercher (int x ); void trier ( ); void insererTête (Object x){ Elément e = new Elément (obj); e.suivant = tête; tête = e; } class Elément { //ceci est une classe interne Object objet; Elément suivant; Elément ( Object x ) { this.objet = x; }

Exercice Ecrire un programme qui crée une liste d'entiers aléatoires, parcourre la liste, et imprime les éléments Utiliser la classe Integer pour créer des objets entiers

Exemple import java.util.Random; class ListeEntiers{ public static void main ( String args [] ) { Random r = new Random(); int n = 1+r.nextInt(10); MaListe lst = new MaListe(); for(int i=0; i<n; i++){ Integer i = new Integer(r.nextInt()); lst.insérerTête(i); //lst.insérerTête( (Object) i); } MaListe.Elément e = lst.tête; while(e != null){ int i = ((Integer)e.objet).intValue(); System.out.println(i + ", "); e = e.suivant; }

classe locale Des classes locales peuvent être déclarée dans le corps d'une méthode, dans une boucle, ou dans un bloc quelconque compris dans {} Ce genre de classe n'est pas un attribut de la classe container –elle ne peut pas être déclarée public, private, protected ou static

polymorphisme Coupé c = new Coupé(…); c est une référence d'un objet de type Coupé mais aussi de type Voiture et aussi VéhiculeMotorisé Ainsi, la relation d'un objet et d'une classe n'est pas statique –en fonction du besoin on peut considérer c Coupé, Voiture ou VéhiculeMotorisé –pour cela, aucune transformation n'est nécessaire –il suffit de faire un sur-casting Ce mécanise (un objet pouvant être considéré de différentes manières) s'appelle Polymorphisme (multiples formes)

Exemple abstract class Personne { String genre; String nom; Personne () { System.out.println("Création d'une Personne"); } public String toString () { return genre + " " + nom; } class Etudiant extends Personne { Etudiant (String t, String s) { this.genre = t; this.nom = s; System.out.println("Création d'un Etudiant"); } class Enseignant extends Personne{ Enseignant (String t, String s) { this.genre = t; this.nom = s; System.out.println("Création d'un Enseignant"); } public String toString(){return "Enseignant";} } class Test { public static void main( String [] a) { Etudiant et = new Etudiant( "M.", "Alain"); Enseignant en = new Enseignant ("Me", "Janette"); saluer (et); saluer (en); } static void saluer ( Personne p) { System.out.println("Bonjour " + p); }

Observations L'exécution de cette exemple produit Création d'une Personne Création d'un Etudiant Création d'une Personne Création d'un Enseignant Bonjour Me Janette ! Cela indique qu'un objet Etudiant est aussi une instance de Personne, de même qu'un objet Enseignant est une instance de Personne On note aussi que la méthode saluer est appelée avec un objet Etudiant puis un objet Enseignant alors qu'elle attend un objet Personne. Cela devrait causer un problème à la compilation. Cependant, dans ce cas, cela fonctionne normalement ! –JAVA a fait une sur-casting de Etudiant et Enseignant vers Personne –cela équivaut à saluer ( (Personne) et ) ; saluer ( (Personne) en ) ;

sur-casting On peut éviter ce sur-casting implicite en réécrivant la méthode saluer() pour Etudiant et Enseignant –on perd l'avantage d'une méthode unique Ainsi, dans ce cas, le sur-casting effectue l'inverse de la réécriture de méthodes

sur-casting explicite Il consiste à transformer une référence d'un objet vers une référence d'une sur-classe Exemple Personne p = new Etudiant("Mle", "X"); Enseignant en = new Enseignant("M", "Y"); p = (Personne) en; String s = en.toString(); System.out.println(s); String s = ((Personne) en).toString(); System.out.println(s);

Illustration Mammifère Chien CanicheLévrier Félin Siamois Tigre Chat Créer ces classes

Exemples Mammifère m; Chien chien; Chat chat; m = new Caniche(); chien = new Mammifère(); chien = new Lévrier(); chat = new Chat(); chat = new Tigre(); chat = new Chien(); Faux Ok Créer la classe TestMammifère avec un main ayant les instructions