Programmation Orientée Objet

Chapitre 5 : HERITAGE ET POLYMORPHISME

Classes: DSI 21

Mme Samia B.ABDELJELIL

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
2 Exemple introductif
 Le problème
 une application a besoin de services dont une partie seulement est
proposée par une classe déjà définie (classe dont on ne possède pas
nécessairement le source)
 ne pas réécrire le code
Application a besoin
Point.class • de manipuler des points (comme le permet la
Un Point classe Point)
•a une position • mais en plus de les dessiner sur l’écran.
•peut être déplacé
•peut calculer sa PointGraphique = Point
distance à l ’origine + une couleur
• ...
+ une opération d’affichage

 Solution en POO : l’héritage (inheritence)

 définir une nouvelle classe à partir de la classe déjà existante
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
3 Terminologie
 Héritage permet de reprendre les caractéristiques d’une classe M
existante pour les étendre et définir ainsi une nouvelle classe F qui
hérite de M.
 Les objets de F possèdent toutes les caractéristiques de M avec en en
plus celles définies dans F

 Point est la classe mère et PointGraphique la classe fille.

 la classe PointGraphique hérite de la classe Point
 la classe PointGraphique est une sous-classe de la classe Point
 la classe Point est la super-classe de la classe PointGraphique

 la relation d'héritage peut être vue comme une relation de

“généralisation/spécialisation” entre une classe (la super-classe)
et plusieurs classes plus spécialisées (ses sous-classes).
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
4 Généralisation/Spécialisation
 La généralisation exprime une relation “est-un” entre une classe et sa
super-classe (chaque instance de la classe est aussi décrite de façon
plus générale par la super- classe).
Animal est une généralisation
super-classe Animal d’Éléphant.
Un éléphant est un animal

spécialisation généralisation
Éléphant est une
spécialisation d’Animal.
Un éléphant est un cas Éléphant sous-classe
particulier animal

 La spécialisation exprime une relation de “particularisation” entre

une classe et sa sous-classe (chaque instance de la sous-classe est
décrite de manière
Chap 5: Héritage plus spécifique)
et Polymorphisme – (Samia BA LEBIBE)
 Héritage
 Une classe ne peut hériter que d'une seule classe
 Toutes les classes dérivent de la classe java.lang.Object
 Une référence vers un objet d'une classe B peut désigner une instance de B
ou une instance d'une de ces classes dérivées (cf polymorphisme pour la
mise en pratique)
 L'opérateur instanceof permet de déterminer la classe d'une instance

L’héritage permet à un objet d’acquérir les propriétés d’un autre objet

➫ factorisation des connaissances :
la classe mère (ou classe de base) est plus générale
➫ elle contient les propriétés communes à toutes les classes filles (on dit aussi
classes dérivées ou héritées).
Les classes filles ont des propriétés plus spécifiques.
➫ On obtient une hierarchie de classes.
Pour exprimer qu’une classe est une classe fille, on utilise le mot-clé extends
dans la déclaration d’une classe :

class <nom classe fille> extends <nom classe mère>

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Conséquences
Que se passe-t-il pour
 les attributs d’instance
 les méthodes de la classe mère
 les constructeurs

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Visibilité des variables et méthodes
Membres public et private
Les méthodes ou attributs
 public sont toujours accessibles par une classe
fille
 private restent inaccessibles, même pour une classe fille !
Evidemment, les attributs privés sont tout de même hérités : même
si on n’a pas directement accès aux attributs, ils sont bien présents !
➫ laisse la liberté de changer l’attribut dans la classe mère sans avoir
à changer quelque chose dans les classes filles.

1 public class Personnage {

2 private String nom;
3 public String getNom(){return nom;}
4 }

1 public class Acteur extends Personnage {

2 ..
3 public String presentation(){
4 return getNom() + ” je suis un acteur”;
5 }
6 } Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Visibilité des variables et méthodes
Membres protégés – protected
Nouvelle portée protected : seules la classe elle-même et ses classes
dérivées ont accès à des membres déclarés protected.

➫ pour les classes qui ne sont pas "dans le même package" protected
est synonyme de private

➫ pour les classes "dans le même package", protected est

synonyme de public

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Visibilité des variables et méthodes
Exemple

Définit le package auquel

appartient la classe. Package tonPackage
Si pas d’instruction package
package monPackage; package par défaut : package tonPackage;
public class Classe2 { { classes définies dans public class Classe4 {
Classe1 o1; le même répertoire } Classe1 o1;
o1.d
o1.b o1.d o1.c package monPackage;
} public class Classe1 {
}

private int a;
package monPackage; package tonPackage;
public class Classe3 int b; public class Classe5
extends Classe1 { protected int c; extends Classe1 {
a int d;
public c c
b d c b d d
} } }

Les mêmes règles de visibilité s’appliquent aux méthodes

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Méthodes de la classe mère
Redéfinition des méthodes
Dans la classe mère, pour les méthodes public ou protected, on a le
choix :
 soit le comportement est le même : on peut/doit omettre
la ré-écriture de la méthode
 soit le comportement est différent : on peut ré-écrire la méthode.
On parle alors de redéfinition de méthodes
➫ utiliser l’annotation @Override avant d’écrire la méthode permet
à java de vérifier si la méthode de la classe mère existe bien pour
éviter des erreurs !

 Redéfinition d’une méthode (method overriding)

 lorsque la classe définit une méthode dont le nom, le type de retour et
le type des arguments sont identiques à ceux d’une méthode dont elle
hérite

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Méthodes de la classe mère
Redéfinition des méthodes

 Lorsqu’une méthode redéfinie par une classe est invoquée pour un

objet de cette classe, c’est la nouvelle définition et non pas celle de
la super-classe qui est invoquée.

 Ilexiste deux références pour éviter les ambiguités entre la méthode

de la classe mère et celle de la classe fille:
(ex : cet appel appelle-t-il une méthode de la classe courante ou de la classe
fille ?)
 this : est une référence sur l’instance de la classe.
 super : est une référence sur l’instance mère.
on pourra donc utiliser super pour appeler spécifiquement une
méthode de la classe mère, et non la méthode de la classe courante.

 Evidemment, on peut ajouter des méthodes spécifiques à la classe

fille !
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Méthodes de la classe mère
Redéfinition des méthodes

A.a = new A();

public class A { B.b = new B();
public void affiche() {
System.out.println("Je suis un A"); a.affiche();  Je suis un A
} a.hello();  Hello

public void hello() { b.hello();  Hello

System.out.println("Hello"); b.affiche();  Je suis un B
}
}

public class B extends A {

public void affiche() { la méthode affiche()est redéfinie

System.out.println("Je suis un B");
} c'est la méthode la plus spécifique qui est
}
exécutée

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Méthodes de la classe mère
Redéfinition des méthodes

 Ne pas confondre redéfinition (overriding) avec surcharge(overloading)

public class A {

public void methodX(int i) {

...
}
}

Surcharge Redéfinition

public class B extends A { public class C extends A {

public void methodX(Color i) { public void methodX(int i) {

... ...
} }
} }

B possède deux C possède une seule

méthodes methodX méthode methodX
(methodX(int) et methodX(Color)) (methodX(int))
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
Constructeurs
 Tout constructeur de la sous-classe doit lancer l'appel du
constructeur de la classe de base

 Si rien n'est prévu, le constructeur sans arguments de la classe

de base est automatiquement appelé (il doit donc exister !)
Sinon, dans la classe dérivée, l'appel d'un constructeur de la
classe de base se fait par l'instruction

super(arguments);
 Cette instruction doit être la première du constructeur de la
sous-classe

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Constructeur par défaut
 Lorsqu'une classe ne définit pas explicitement de constructeur, elle possède un
constructeur par défaut :
 sans paramètres
 de corps vide
 inexistant si un autre constructeur existe
public class A {

public A()
{
...
}
..}
public class B extends A {

// attributs
String nom; public B() { Constructeur par
super();
// méthodes
}
défaut implicite
String getNom() {
return nom;
}
...
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
}
 Héritage
Constructeur par défaut
public class ClasseA {
double x;
// constructeur Constructeur explicite
public ClasseA(double x) { masque constructeur par défaut
this.x = x;
}
} Pas de constructeur
sans paramètres

public class ClasseB extends ClasseA {

double y = 0; public ClasseB(){ Constructeur
super(); par défaut
// pas de constructeur } implicite
}

C:>javac ClasseB.java
ClasseB.java:3: No constructor matching ClasseA() found in class ClasseA.
public ClasseB() {
^
1 error

Compilation exited abnormally with code 1 at Sat Jan 29 09:34:24

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
Constructeur paramétré (1)
class Personne {
…
public Personne() {
nom = "inconnu" ; age = 0;}
public Personne(String nom) {
this.nom = nom;}
public Personne(String nom, int age) {
this.nom = nom; this.age = age;
}
}
class Salarie extends Personne {
double salaire;
public Salarie(double salaire){ par défaut, ce salarié a un
nom « inconnu" et un age 0
// appel automatique de Personne()
this.salaire = salaire;
}}
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
Constructeur paramétré (2)
class Personne {
String nom;
int age;

public Personne(String nom)

{this.nom = nom;}

public Personne(String nom, int age)

{this.nom = nom; this.age = age;}

…}

… Salarie extends Personne {

class
double salaire;
public Salarie(double salaire, String nom, int age){
super(nom, age);
this.salaire = salaire;}
}

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Constructeur paramétré (3)
class Personne {
…
public Personne(String nom, int age) {……}
public Personne(String nom) {……..}
// Attention, pas de constructeur par défaut
}
class Salarie extends Personne {
…
public Salarie(double salaire){
// Pas d'appel d'un constructeur de la
// classe de base avec super
// JAVA refusera de compiler ce programme
this.salaire = salaire
}

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
1
2
public class Personne {
private String nom;
Exemple
3 // Constructeur
4 public Personne(String nom){
5 this.nom = nom;
6 }
7
8 public String presentation(){
9 return ”Je m’appelle” + nom;
10 }
11 }

1 public class Etudiant extends Personne {

2
double moy;
3
4 public Etudiant(String nom, double m){
5 super(nom); moy = m;
6 }
7 @Override //Redéfinition de la méthode presentation
8 public String presentation(){
9 return super.presentation() + ” je suis un étudiant, ma moyenne est
10 : ” +moy;
11 }
12 public static void main(String[] args){
13 Etudiant e1 = new Etudiant(”Ali”, 12.5);
14 System.out.println( e1.presentation());
15 } }
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
Opérateur instanceof

Opérateur pour vérifier si une classe est bien un instance d’une classe.
1 public class Personne { . . . }

1 public class Etudiant extends Personne { . . . }

1 public class EtudiantDSI extends Etudiant { . . . }

1 public class Enseignant extends Personne { . . . }

2 ...
5 public s t a t i c void main(String[] args){
6 EtudiantDSI edsi1 = new EtudiantDSI();
7 System.out.println(edsi1 instanceof Personne);
8 System.out.println(edsi1 instanceof Etudiant);
9 System.out.println(edsi1 instanceof Enseignant);

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Opérateur instanceof

Opérateur pour vérifier si une classe est bien un instance d’une classe.
1 public class Personne { . . . }

1 public class Etudiant extends Personne { . . . }

1 public class EtudiantDSI extends Etudiant { . . . }

1 public class Enseignant extends Personne { . . . }

2 ...
5 public s t a t i c void main(String[] args){
6 EtudiantDSI edsi1 = new EtudiantDSI();
7 System.out.println(edsi1 instanceof Personne); // true
8 System.out.println(edsi1 instanceof Etudiant); // true
9 System.out.println(edsi1 instanceof Enseignant); // false

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Méthodes final
 Méthodes finales
 public final void méthodeX(….) {…. }
 Rôle: « verrouiller » la méthode pour interdire toute éventuelle
redéfinition dans les sous-classes
 Efficacité: utiliser final que lorsque le code n'est pas trop gros ou lorsque
l’on veut explicitement éviter toute redéfinition

 méthodes private sont implicitement final (elles ne peuvent être redéfinies)

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Classes final
 Une classe peut être définie comme finale
 public final class UneClasse {
…
}
 interdit tout héritage pour cette classe qui ne pourra être sous-classée

 toutes les méthodes à l’intérieur de la classe seront implicitement finales

(elles ne peuvent être redéfinies)
 exemple : la classe String est finale

 Attention à l’usage de final, prendre garde de ne pas privilégier une

supposée efficacité au détriment des éventuelles possibilités de
réutiliser la classe par héritage.

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

Poymorphisme
UpCasting/downCasting
Lien dynamique

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Polymorphisme
 Le terme polymorphisme (« multiforme »), ) décrit la caractéristique d'un élément
qui peut se présenter sous différentes formes.

 En programmation par objets, on appelle polymorphisme

 le fait qu’un objet d’une classe puisse être manipulé comme s’il appartenait à
une autre classe.
 le fait que la même opération puisse se comporter différemment sur
différentes classes de la hiérarchie.

 "Le polymorphisme constitue la troisième caractéristique essentielle d'un

langage orienté objet après l'abstraction des données (encapsulation) et
l'héritage

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Upcasting / downCasting

1.Upcasting : C’est le cast d’un objet fille à un objet parent

2.Downcasting: c’est e cast d’un objet parent à un objet fille

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

Upcasting / downCasting
upcasting

downcasting

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Héritage
Surclassement ou UpCasting
 Tout objet instance de la classe B peut être aussi vu comme une
instance de la classe A (A est la classe mère)
 Cette relation est directement supportée par le langage JAVA :
 à une référence déclarée de type A, il est possible d'affecter une valeur qui
est une référence vers un objet de type B (surclassement ou upcasting)
Etudiant Etudiant e;
A
e = new EtudiantSportif(...);
B C

D E
EtudiantSportif
F
C c;
c = new D();
c = new E();
c = new F();
c = new A();
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE) c = new B();
 Héritage
Surclassement ou UpCasting
 Lorsqu'un objet est "sur-classé" il est vu par le compilateur comme un objet du
type de la référence utilisée pour le désigner
 Ses fonctionnalités sont alors restreintes à celles proposées par la classe du
type de la référence
EtudiantSportif es;
es = new EtudiantSportif("DUPONT","Jean",25,..,"Badminton",..);

Etudiant e; es
e = es; / / upcasting
ou casting implicite
e
e.affiche();
es.affiche(); instanceOf
DUPONT
e.nbInscriptions();
Jean
es.nbInscriptions();
25
es.bonusSpor t i f ( ) ;
e.bonusSportif(); ...
Badminton
Le compilateur refuse ce
...
message: pas de méthode
bonusSportif définie dans
la classe Etudiant Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Héritage
Lien dynamique - Résolution des
Lorsqu'une méthode d'un objet est accédée au messages
travers d'une référence "surclassée", c'est la
méthode telle qu'elle est définie au niveau de
la classe effective de l'objet qui est en fait Etudiant
invoquée et exécutée
public void a f f i c h e ( ) {
Upcasting  casting implicite System.out .pri n t l n (
"Nom : "+nom+"\n"
Mere m = new Fille(…) "Prénom : "+prénom+"\n"
Etudiant e = new EtudiantSportif( "DUPONT","Jean",25,.., "Age : "+age+ . . . ) ;
"Badminton",..); }
?
e.affiche();
e

instanceOf ? EtudiantSportif
DUPONT
Nom : DUPONT public void a f f i c h e ( ) {
Jean
Prénom : Jean su p e r .affic h e();
25 Age : 25 System.out .pri n t l n (
... … "Sport" : "+sport+"\n"
Sport : Badminton +...);
Badminton }
...Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Polymorphisme
DownCasting
ClasseX o b j = …
ClasseA a = (ClasseA) obj;

 Le downcasting (ou transtypage) permet de « forcer un type » à la compilation

 C’est une « promesse » que l’on fait au moment de la compilation.

 Pour que le transtypage soit valide, il faut qu’à l’exécution le type effectif de
obj soit « compatible » avec le type ClasseA
 Compatible : obj possède la même classe classeA ou n’importe quelle
sous classe de ClasseA (il faut que obj instanceof ClasseA retourne true)
 Si la promesse n’est pas tenue une erreur d’exécution se produit.

 ClassCastException est levée et arrêt de l’exécution

java.lang.ClassCastException: ClasseX
at Test.main(Test.java:52)

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Polymorphisme
ClasseA

méthodeX()

ClasseB ClasseC

méthodeX()

ClasseD ClasseE ClasseF

méthodeX()

ClasseA obj A;
Surclassement = upcasting
la référence peut
un cas particulier de
désigner des objets de polymorphisme
objA = . . . classe différente
(n’importe quelle sous (polymorphisme par sous-
classe de ClasseA)
typage)
objA.methodeX();
+
manipulation uniforme des
Lien dynamique
Le comportement est
objets de plusieurs classes
différent selon la classe par l'intermédiaire d'une
effective de l’objet
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
classe de base commune
 Polymorphisme
l i s t e peut contenir des étudiants de n’importe queltype

GroupeTD td1 = new GroupeTD(); public class GroupeTD{

td1.ajouter(new Etudiant("DUPONT", …)); E t u d i a n t [ ] l i s t e = new E t u d i a n t [ 3 0 ] ;
td1.ajouter(new EtudiantSportif("BIDULE",
i n t nbEtudiants = 0 ;
" L o u i s " , …, " s k i a l p i n " ) ;
. .pu
. b lic void ajouter (Et u dian t e) {
i f (nbEtudiants < l i s t e . l e n g t h )
Etudiant
{ liste [nb E tu dia n ts ] = e ;
public void a f f i c h e ( ) { nbEtudiants++;
System.o u t .p ri n t l n ( }
"Nom : "+nom+"\n" }
"Prénom : public void afficherListe ( ) {
"+prénom+"\n" "Age : f o r ( i n t i=0;i<nbEtudiants; i + + )
"+age+ . . . ) ;
liste[i].affiche();
}
} }

EtudiantSportif EtudiantEtranger Si un nouveau

type d’étudiant
public void a f f i c h e ( ) { est défini,
public void a f f i c h e ( ) {
super.affiche(); Le code de
super.affiche();
System.out.println(
System.out.println( GroupeTD
" N a t i o n a l i t é " : "+pays+"\n"
"Sport" : "+sport+"\n" reste inchangé
+...);
+...);
}
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
}
 Polymorphisme
 En utilisant le polymorphisme en association à la liaison
dynamique
 plus besoin de distinguer différents cas en fonction de la classe des objets
 possible de définir de nouvelles fonctionnalités en héritant de nouveaux
types de données à partir d'une classe de base commune sans avoir
besoin de modifier le code qui manipule l'interface de la classe de base

 Développement plus rapide

 Plus grande simplicité et meilleure organisation du code
 Programmes plus facilement extensibles
 Maintenance du code plus aisée

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Surcharge et Polymorphisme
public class ClasseC {

public static void methodeX(ClasseA a){

surcharge
ClasseA System.out.println("param typeA");
}

ClasseB public static void methodeX(ClasseB b){

System.out.println("param typeB");
}
}
ClasseA refA = new ClasseA();
ClasseC.methodX(refA); param TypeA
ClasseB refB = new ClasseB();
ClasseC.methodX(refB); param TypeB
refA = refB; // upCasting
ClasseC.methodX(refA); ?????TypeA
param

invokestatic … <Method void ClasseA )>

methodX(
Byte-code

Le choix de la méthode à exécuter est effectué à la compilation en fonctiondes types déclarés : Sélectionstatique
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
 Polymorphisme
A propos de equals
 Tester l’égalité de deux objets de la mêmeclasse
public class Object {
@Override
...
public boolean equals(Object o) public boolean equals(Object o) {
return t h i s == o i f ( t h i s == o)
} return t r u e ;
...
}
i f ( ! (o instanceof Po i n t ) )
return f aequals(Point
public boolean lse; pt) {
return
Point ptthis.x
= ( Po i n== pt.x
t ) o; / / && this.y == pt.y;
downcasting
public class Point { }
retu rn this . x == pt o . x && t hi s . y == pt
o.y ;
private double x ;
private double y ; redéfinir (overrides) la méthode
} equals(Object o) héritée de Object
...
Point p1 = new Point(15,11);
} Point p2 = new Point(15,11);
p1.equals(p2) - -- ->> true
true
Object o = p2;
p1.equals(o) ---->> false
true

o.equals(p1) ---->> false

true

Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)

 Upcasting/Downcasting Polymorphisme
class A {
A public void ma() {
ma() System.out.println("methode ma définie dans A");
}
} class E extends C {
B C public void ma() {
System.out.println("methode ma redéfinie dans E");
}
public void me() {
D E }
System.out.println("methode me définie dans E");
ma() } class F extends E {
me()
public void mf() {

C c = new F ( ) ;
F } System.out.println("methode mf définie dans f");
public void me() {
mf()
}
System.out.println("methode me redéfinie dans F");}
me()

compilation exécution
c.ma( ) ; La classe C hérite d'une méthode ma  méthode ma définie dans E

Cannot find symbol : metod mf()

c.mf ( ) ;
Pas de méthode mf() définie au niveau de la classe C

B b = c; Incompatible types
Un C n'est pas un B
Incompatible types
E e = c; Un C n'est pas forcément un E
E e = (E)c; Transtypage (Dowcasting), le compilateur ne fait pas de
e.me();  méthode me définie dans F
vérification La classe E définit bien une méthode me
Chap 5: Héritage et Polymorphisme – (Samia BA LEBIBE)
Transtypage (Dowcasting), le compilateur ne fait pas de ClassCastException Un F n'est pas
D d = (D) c ; vérification un D