Héritage

Polymorphisme, classe abstraite et interface

Diagramme de classe UML

Principes de classification• La modélisation des entités du monde réel peut nécessiter

une classification des objets qui le composent :

– distribution systématique en catégories selon des critères précis

• Une « super-classe » partage les propriétés communes de ses « sous-classes » ; la généralisation/spécialisation est un mécanisme de gestion de la complexité

Animal

Herbivore Carnivore

FélinEscargot

Animal

Invertébré Vertébré

Ovin FélinEscargot Ovin

Spé

cial

isat

ion

Gé

né

ralis

atio

n

Mécanisme d’héritage

• Une classe qui hérite d'une autre en possèdetoutes les propriétés / comportements, et possèdeen plus des propriétés / comportements qui luisont propres.

• L'héritage successif de classes permet de définirune hiérarchie de classes qui se compose de super-classes (classes de base) et de sous-classes (classesdérivées).

Redondance et évolutivité … MachinePneuMachineElec

+ machineElec(String)

+ getNom() : String+ getTension() : float+ puissance() : float

+ machinePneu(String)

+ getNom() : String+ getPression() : float+ puissance() : float

- nom : String- tension : float- intensité : float

- nom : String- pression : float- débit : float

MachineHydro

- …

Si puissance devient entière ?

Si le nom est remplacer par un code entier ?

Si on ajoute un attribut poids ?

POO et Héritage

• L'héritage est un mécanisme de réutilisation par lequelune classe est définie comme une spécialisation(extension) d'une classe plus générale :

– Enrichissement : des attributs et/ou méthodes supplémentaires peuvent être définis dans la sous-classe

– Spécialisation : des méthodes héritées sont redéfinies dans la classe dérivée

• Ce mécanisme permet de fabriquer des classes à partird'autres classes. La relation d’héritage est transitive.

• Il permet d’éviter la duplication et facilite donc lamaintenance des programmes (et modèles).

Equivalence

Machine

MachinePneu

- nom :String

+ Machine(String)+ puissance() : float

MachineElec

- tension : float- intensité : float

+ MachineElec(String)

+ getTension() : float+ puissance() : float

- pression : float- débit : float

+ MachinePneu(String)

+ getPression() : float+ puissance() : float

MachinePneuMachineElec

+ machineElec(String)

+ getNom() : String+ getTension() : float+ puissance() : float

+ machinePneu(String)

+ getNom() : String+ getPression() : float+ puissance() : float

- nom : String- tension : float- intensité : float

- nom : String- pression : float- débit : float

Avec héritage

Sans héritage

Enrichissement

Spécialisation

Héritage Multiple• L'héritage multiple est la faculté qu'une classe hérite

simultanément de plusieurs classes.

• Or, ce type d'héritage pose plusieurs problèmes lorsqu'une classe hérite de deux classes héritant elles-mêmes d'une troisième : On a des ambiguïtés …– Non retenu en Java

Animal

Herbivore Carnivore Omnivore

Animal

Herbivore Carnivore

Omnivore

Héritage ou composition• L'héritage est fondamentalement différent de la

composition– Il doit être utilisé pour décrire une relation « est-un »

– il ne doit jamais décrire une relation « appartient à»

Animal

Mammifère

Tête

Animal

Corps Membre

4

Bovin Un mammifère est-t-il un animal ? ouiUn corps est-il un animal ? nonMais un corps appartient à un animal

Mise en œuvre de l’héritage en Java

Diagramme de classe UML

Héritage en Java • Pour spécifier qu'une classe hérite d'une autre classe,

on utilise le mot-clé extends : class D extends B {

//définition de membres spécifiques de B …}

• Dès lors :

– Tout objet de la classe dérivée D possède tous lesmembres de la classe de base B, en plus de sespropres membres• tout objet de la classe D ne peut pas manipuler les

membres privés de la classe B

– Tout objet de la classe dérivée D est aussi uneinstance de la classe B

Exemple de synthèseclass Figure {private double x, y;public Figure(){

x = 10;y = 20;

}public double getX() {

return x;}public double getY() {

return x;}

}class Rectangle extends Figure {private double hauteur, largeur;public Rectangle(double h, double l) {hauteur = h;largeur = l;

}}

Définition de la classe de base

Définition de la classe de dérivée

public static void main(String []args) {Rectangle r = new Rectangle(1, 2);double x, d;x = r.getX();d = distanceCO(r);

}static double distanceCO(Figure f){

double d;d = f.getX()*f.getX() +f.getY()*f.getY();

return d;}

}

Un rectangle utilise une méthode de sa classe de base

Un rectangle est aussi une figure

Code donné à titre illustratif

Héritage ou composition

Animal

Mammifère

Tête

Mammifère

Corps Membre

4

class Animal {…}class Mammifere

extends Animal {…}

class Tete{…}class Corps {…}class Membre {…}class Mammifere {

private Tete t;private Corps c;private Membre []tm; …}

(une possibilité)

« est un » « possède »

Ordre de création dans les objets

Animal

Mammifère

Bovin

Vache

static public void main(String args[]) {Vache maVache = new Vache(....); ...

Le processus de création est le suivant :1. La partie static de Animal2. La partie static de Mammifère3. La partie static de Bovin4. La partie static de Vache5. La partie non static de Animal6. La partie non static de Mammifère7. La partie non static de Bovin8. La partie non static de Vache

Félin

Tigre

La partie statique est crée en premier (une seule fois) dela classe générale vers les classes de plus en plusspécialisées.Puis, la partie non statique est créée pour chaque objetde la classe générale vers les classes de plus en plusspécialisées.

Héritage de constructeur• Pour forcer l'appel d'un constructeur précis de la classe de

base afin d’initialiser les attributs hérités, on utilise le mot réservé super.

class B {int a;…public B(int na) {a = na;…

}}class D extends B {int b;…

public D(int na, int nb) {super(na);b = nb;…

}}

Initialise les attributs de B

Initialise les attributs de la classe de base

Initialise les attributs spécifiques de D

Héritage de constructeur• Un constructeur n’est pas hérité, mais peut être appelé dans

celui des classes dérivées. L’appel du constructeur de la classe de base doit être la première instruction du constructeur :

– dans ce cas, on ne pourra pas avoir simultanément l'appel à un autre constructeur de la classe dérivée

class B {int a;public B(int na) {…}

}class D extends B {int b;public D(int na, int nb) {super(na);…

}}

class D1 extends B {int b;public D1(int na, int nb) {super(na);…

}public D1() {

super(0);this(0,0);…

}}

call to this must be first statement in constructor

: il faut choisir !

Constructeur par défaut et héritage • Par défaut, le constructeur d’une classe dérivée peut appeler le

constructeur "par défaut" (celui qui ne reçoit pas de paramètres)de la classe de base :

– dans ce cas, le constructeur sans paramètre doit existerexplicitement ou implicitement dans la classe de base car il estimplicitement appelé

class B {int a;B(int na) {

a = na;}

}class D1 extends B {

int b;D1(int nb) {

b = nb;}

}

cannot find symbol constructor B()

class B {int a;B(int na) {

a = na;}B() {}

}class D1 extends B {

int b;D1(int nb) {

b = nb;}

}

class B {int a;B(int na) {

a = na;}

}class D1 extends B {

int b;D1(int nb) {

super(0);b = nb;

}}

Appelle implicite de B()

Constructeur et héritage • Il faut s’assurer que l’instanciation des objets :

– Permette d’initialiser l’ensemble des données membres propres ethéritées

– Conseil de conception

– A un niveau donné, un constructeur appelle le constructeur deniveau supérieur via un super et tous les autres constructeursl’appelle avec un this

class B {…B(int na, int nb) {

…}

}

class D extends B{…D(int na, int nb, int nc) {

super(na, nb);…

}D(int na, int nc) {

this(na, na, nc);} D() {

this(0, 0, 0);}

}

Redéfinition (outrepassement) de méthodes

• A fin de spécialiser le comportement d’une classe dérivée, on veut modifier certaines méthodes de la classe de base :– les objets des classes dérivées répondront au même

message avec des comportements différenciés

• Une classe dérivée peut redéfinir des méthodes de même signature existant dans une de ses classes de base (directes ou indirectes) :– Le terme anglophone est "overriding". On parle aussi

d’outrepassement ou de masquage

– La méthode redéfinie doit avoir la même signature à la différence de la surcharge simple :• surdéfinition (overloading) et redéfinition (overriding) peuvent

coexister

Exemple de synthèseclass Figure {private double x, y;public Figure(double nx, double ny){…

}public void put() {System.out.println(x + "," + y);

}}class Rectangle extends Figure {private double hauteur, largeur;public Rectangle(double h, double l,double nx, double ny) {super(nx, ny);…

}public void put() {System.out.println(hauteur +

"," + largeur);}}

Définition de la méthodeput dans la classe de base

Redéfinition de la méthodeput dans la classe dérivée

Appel de la méthodeput de Figure

Code donné à titre illustratif

Figure f ;r = new Figure(2, 2);r.put();Rectangle r ;r = new Rectangle(2, 4, 1, 2);r.put();

Appel de la méthode redéfinieput de Rectangle

Résolution de portée : super

• S’il existe dans une classe B une méthode xxx accessible demême signature qu’une méthode d’une classe dérivée D, pouraccéder dans D à la méthode xxx de B, il faut faire précéder sonnom de « super ».

Le mot clé super permetd’appeler la méthode

put de Figure

class Figure {private double x, y;public Figure(double nx, double ny){

x = nx;y = ny;

}public void put() {System.out.println(x + "," + y);

}}

class Rectangle extends Figure {private double hauteur, largeur;public Rectangle(double h, double l,…}public void put() {

super.put();System.out.println("H"+ " = " + hauteur);System.out.println("L"+ " = " + largeur);

}}

super ne peut être utilisé que dans un contexte d’instanceOn ne peut avoir qu’un « super. »

Compatibilité classe dérivée vers classe de base• Si D est une sous-classe B, alors tout objet de type B peut

être remplacé par un objet de type D sans altérer lespropriétés désirables du programme concerné :– L’upcasting consiste à affecter à une variable de type

référence d’un objet de la classe B la référence d’unobjet de type la classe D (D est surclassé)

– L’upcasting (surclassement) implicite et explicite sontpermis en Java

• L'inverse, downcasting (sousclassement), est possible maisnécessite l'utilisation d'un transtypage, cependant àl'exécution la référence affectée doit être de typecompatible :– classe dérivée– sous-classe de la classe dérivée

• Le downcasting explicite est permis, pas l’implicite.

Exempleclass B {

}

class D extends B {

}

Correct

Exception in thread … java.lang.ClassCastException: B

cannot be cast to D …

B b = new B();D d = new D();d = b;

B b = new B();D d = new D();b = d;

XXX.java:…: incompatible types

B b = new B();D d = new D();d = (D)b;

B b = …;D d = …;b = d;

Si la classe de d est une sous classede celle de B alors d est sur classélors de l’affectation. Dans le cas inverse,il s’agit d’un sous classement

Remarques• Les données membres (variables) redéfinies sont

« masquées ».

• Les méthodes de classe (static) redéfinies sont masquées.

• Limitations :

– Lors d'une redéfinition, les droits d'accès d'une méthode nepeuvent pas être restreints.

– Lors d'une redéfinition, une méthode de classe (static) nepeut pas être redéfinie par une méthode d'instance (etréciproquement). Cependant, une variable de classe peutêtre masquée par une variable d’instance (etréciproquement), mais c’est à éviter.

• On rappelle qu’une classe dérivée peut accéder auxmembres (accessibles) redéfinis de sa classe de base enutilisant super.

Polymorphisme

• En programmation objet, le polymorphisme (plusieursformes) est la capacité qu'une même opération puisse secomporter différemment en fonction de la classeconsidérée :– D’un point de vue statique : un objet de la classe dérivée

est considéré comme objet de la classe de la classe debase qui le référence (upcasting). Ceci est vérifié à lacompilation.

– D’un point de vue dynamique : la classe de l’objetréférencé détermine la méthode à appeler. La gestion dupolymorphisme est assurée par la machine virtuelledynamiquement à l'exécution (choix retardé).

• Cette forme de polymorphisme ne s'applique qu'auxméthodes d'instance au sein d'une hiérarchie de classes(impossible les méthodes statiques).

Règles de résolution

• Pour que le polymorphisme puisse fonctionner, les appelsde méthodes sont résolus à l'exécution (run-time) et nonà la compilation (compilation-time).

• Cependant, la résolution des appels de méthodes se faiten deux temps :– vérification statique à la compilation : la classe déclarée

doit posséder une méthode avec la signature correspondante

– résolution à l'exécution (résolution retardée)

– Attention :

• Le polymorphisme n’est utilisé que pour les méthodesd’instance, le choix pour les méthodes statiques esteffectué lors de la compilation donc déterminer par letype de la variable / classe appelant la méthode

Classe Object• La classe Object est la classe de base de toutes les

classes Java (racine de la hiérarchie de classes).• Toutes les classes sont compatibles avec la classe

Object.• Toute classe de base utilisateur est implicitement

dérivée de cette classe :– class MaClasse { class Maclass extends Object { …

• En particulier, toutes ses méthodes sont donc héritéespar toutes les classes, on peut citer :– toString() de la classe Object renvoie le nom de la classe,

suivi du séparateur @, lui-même suivi par la valeur dehachage de l'objet

– La méthode getClass() renvoie un objet de la classe Classqui représente la classe de l'objet

– La méthode equals(Object) implémente unecomparaison par défaut. Sa définition dans Objectcompare les références (à redéfinir).

Opérateur instanceof

• Opérateur qui permet de tester le type effectif d’un objet. L'expression o instanceof nomClasse est vraie si :

– l'objet référencé par o est une instance de nomClasse ou d'une classe (ou interface) de niveau supérieur

class B {}class D1 extends B {}class D2 extends B {}B d1 = new D1();…d1 instanceof B → trued1 instanceof D1 → trued1 instanceof Object → trued1 instanceof D2 → false

– Il permet de lever des ambiguïtés à l'exécution pour vérifier des compatibilités entre classes (éviter des ClassCastException)

Classes et méthodes final

• Le mot-clé final devant une classe indique :

– qu'elle ne peut avoir de descendance.

• Le mot-clé final devant une méthode indique :

– qu'elle ne peut être redéfinie, cependant, elle peut être surdéfinie.

– que le comportement de cette méthode ne doit pas être remis en cause dans les classes dérivées

• Une classe dont toutes les méthodes sont final peut encore être dérivée, une classe final ne peut plus l'être.

Classe abstraite

• Dans une hiérarchie de classes constituée de classes de très hautniveau, il peut être nécessaire de créer une classe sans pouvoirdéfinir une ou plusieurs méthodes. La définition du code est alorslaissée aux classes dérivée.

• Ce type de classe est appelée classe abstraite :

– Elle doit être qualifiée par le modificateur abstract

– Toutes les méthodes de cette classe qui ne sont pas définies doivent elles aussi être marquées par le mot réservé abstract :• Méthode abstraite : méthode n'ayant pas d'implémentation

– Une classe abstraite ne peut pas être instanciée, mais une référence d'un type abstrait peut exister

– Une classe déclarée final ne peut être abstraite

Contraintes et utilités• Une classe est également abstraite si elle n'est pas

entièrement implémentée : – si une classe a (au moins) une méthode abstraite alors cette

classe est abstraite– ses classes dérivées doivent terminer son implémentation

• Les méthodes static, private et final ne peuvent pas être abstraites.

• Les classes abstraites sont particulièrement utiles pour mettre en œuvre le polymorphisme : – l'utilisation du nom d'une classe abstraite comme type pour

une (des) référence(s) est toujours possible– la classe abstraite peut contenir l'interface indispensable à

toutes les classes dérivées (partie générique)– Une classe peut être déclarée abstraite mais ne contenir que

des méthodes implémentées, si elle n’a pas vocation a possédé ses propres instances (ses classes dérivée en auront)

Interface• Une interface au sens de Java correspond à une classe totalement

abstraite dans laquelle :

– toutes les méthodes sont implicitement public et abstract :

• pas de constructeur

– tous les champs sont implicitement public, static et final :

• ils doivent donc être initialisés

• Une interface est la spécification d’un ensemble de services que doivent réaliser les objets d’une classe (messages auxquels un objet doit répondre) pour « travailler » avec une autre classe

• Notion particulièrement utilisée en « programmation avancée » java (interface graphique, multi threading, …)

• Depuis la version 8 de Java, il est possible de définir des méthode par défaut et des champs et méthodes statiques.

Définition et implémentation• Une interface se définit comme une classe via le mot-clé

interface :[modificateurs] interface Forme {

membres}

• Une classe implémente une ou plusieurs interfaces :[modificateurs] class Rectangle implements Forme, Autre {

membres}

• Pour qu'une classe implémentant une interface ne soit pasabstraite, elle doit fournir une implémentation à toutes lesméthodes spécifiées par l'interface (sauf les méthodes pardéfaut).

• L’interface d’une classe est l’union de ces facettes(interfaces implémentées) et de son interface propre.

• Une interface peut servir de type, les classes servant à eninstancier les objets doivent cependant êtrecomplètement définies.

Représentation UML

interface Forme implements Forme {double surface( );

}class Rectangle{

private double largeur,hauteur;public Rectangle(double nLargeur,

double nHauteur) {largeur = nLargeur;hauteur = nHauteur;

}public double surface() {

return largeur * hauteur;}

}

Exemple (modificateurs implicites)

interface Inter1 {

int NMAX = 10;

int test1(int a);

}

interface Inter2 {

int test2(int a);

}

class Imple1 implements Inter1, inter2 {

public int test1(int a) {

if(a==NMAX) …

…

public int test2(int a) {

…

}

implicitement static et public

implicitement public

explicitement public

Ambiguïtés• Une interface peut hériter d'une autre interface.• Une classe peut implémenter plusieurs interfaces (multi

facettes) :– il peut y avoir conflit de nom si les interfaces possèdent des

constantes homonymiques (risque si les interfaces héritent d'une interface identique)

– à l'opposé, des méthodes de signatures différentes peuvent exister

public interface Inter2 {int NMAX = 10;int test1(int a);void test2(int a); …

}public interface Inter1 {int NMAX = 20;int test1(int a);void test2(int a,int b); …

}

public class Imple1 implements Inter1, Inter2 {…

public int test1(int a) {…public void test2(int a, int b) {…public void test2(int) {…

}

Exemple : defaultinterface Affichable {

default void put() {System.out.println("Instance de " + this.getClass().getName());

}}

class Point implements Affichable {private int x, y;public Point(int nx, int ny) {

x = nx;y = ny;

}public void put() {

System.out.println("(" + x + ", " + y + ")");}

}

class Point implements Affichable {private int x, y;public Point(int nx, int ny) {

x = nx;y = ny;

}}

Point p = new Point(1,2);p.put();

(1, 2)Instance de Point

Conseils de conception

• Faire des diagrammes de classe (par exemple en UML) :– Pour comprendre les interactions entre les classes (qui a

besoin d’une référence sur qui, qui hérite de qui)

– Pour savoir ou placer une méthode et penser les droits d'accès

• Attention l'héritage n'est pas une réponse à tout, lacomposition est aussi utile.– l'héritage est une relation est un

– la composition / agrégation est relation appartient à

• Placer les informations communes dans la classe de base :principe d'économie et de non redondance de l'information

• N'utiliser l'héritage que lorsque c'est pertinent : c'est-à-direlorsque toutes les informations de la classe de base sontbien utilisées par une classe dérivée

Conclusions• L'héritage est un mécanisme de réutilisation des langages

objet permettant de dériver une nouvelle classe à partird'une classe existante en récupérant ses membres.

• Au sein d'une hiérarchie de classes, la classe de base estcompatible avec toutes ses classes dérivées :– Cette caractéristique est exploitée par le polymorphisme qui

permet d'appeler lors de l'exécution la méthode correspondantau type d'objet instancié

• Les classes abstraites sont des classes partiellementdéfinies qui permettent de construire des classes de hautniveau.

• Les interfaces sont des classes complètement abstraitesqui permettent de contourner certaines difficultés liées àl'héritage multiple.

Cinquième série d’exercices ...

?

Diagramme de classes pour héritage

Seuls les nouveaux membres et les membres redéfinis apparaissent

Diagramme de classes pour Classe Abstraite

Point{abstract}

+ isVisible() : bool {abstract}

Diagramme de classes pour interface

Synthèse modificateurs

Modificateur Comportement

public La méthode ou le champ est accessible aux méthodes de

toutes les autres classes.

protected La méthode ou le champ est accessible à toutes les

méthodes du fichier et du package, ou par les méthodes

des sous-classes (hors package).

« friendly » La méthode ou le champ est accessible à toutes des

méthodes du fichier et du package (par défaut).

private L’accès de la méthode ou du champ est réservé aux

autres méthodes de la même classe.

final La méthode ne peut être modifiée (redéfinition lors de

l'héritage interdite).

static La méthode appartient simultanément à tous les objets de

la classe.