HÉRITAGE & POLYMORPHISME

Université Alger1/ Faculté de sciences/ Département

M
I
 Plan
Héri ta ge
 Défi ni ti ons
 L’a rbre de toutes l es
cl a sses
 Redéfi ni ti on des méthodes
□ Surcha rge et ma squa ge
□ Redéfi ni ti on des
méthodes
 Héri ta ge et constructeurs
 Cl a sse Object
 M éthodes et cl a sses fi na l es
 Le pol ymorphi sme
□ Surcl a ssement
□ Souscl a ssement

Univ. Alger1/FS/MI DjaafriLyes

 Définitions (1/4)

L’héritage est un class A class B

attributs attribut
mécanisme offert par les méthodes méthodes

Hérite de
Hérite de
langages OO permettant
de créer une nouvelle
class C
classe à partir d’une ou attributs
méthodes
plusieurs autres classes en
La classe C utilise les attributs et les
partageant leurs attributs
méthodes déclarés à son niveau
et leurs méthodes. La classe C utilise par héritage les attributs
et les méthodes déclarés dans les classes A
et B
Univ. Alger1/FS/MI DjaafriLyes
 Définitions (2/4)
class A
attribut
Java permet seulement d’hériter une seule méthodes
classe → héritage simple

Hérite de
La classe B hérite de la classe A :
 A est la classe mère et B la classe fille class B
attributs
 B est la classe dérivée de A méthodes
 la classe B est une sous-classe de la La classe B utilise les attributs et
classe A les méthodes déclarés à son niveau
La classe B utilise par héritage les
 la classe A est la super-classe de la attributs et les méthodes déclarés
dans la classes A
classe B Univ. Alger1/FS/MI DjaafriLyes
 Définitions (3/4)

class
 L’héritage exprime la relation « est un class
Personn
» entre une sous classe et une super Animal
e
classe.

généralisation

généralisation
spécialisation

spécialisation
L’héritage exprime la relation de

est un


est un
généralisation entre une super classe
et une sous classe
 L’héritage exprime la relation de class class
spécialisation entre une sous classe Oiseau Employe
et une super classe

Univ. Alger1/FS/MI DjaafriLyes

 Définitions (4/4)
L’héritage peut s’exprimer entre des classes sur
plusieurs niveaux.
Animal

Mammifère

Carnivore Carnivore
PointNommé

Univ. Alger1/FS/MI DjaafriLyes

 Intérêts de l’héritage

 Spécialisation, enrichissement : une nouvelle classe utilise

les attributs et les méthodes d ’une classe en y ajoutant
et/ou des opérations particulières à la nouvelle classe

 Réutilisation : évite de réécrire du code existant et

parfois on ne possède pas les sources de la classe à
hériter

 Redéfinition : une nouvelle classe redéfinit les attributs

et opérations d’une classe de manière à en changer le
sens et/ou le comportement pour le cas particulier défini
par la nouvelle classe
Univ. Alger1/FS/MI DjaafriLyes
 Héritage et Java
 Java utilise le mot clé extends pour réaliser l’héritage entre
deux classes.
 Si la classe B hérite de la classe A alors, on écrit le code suivant :

class A { class A
//membres de A
}

class B extends A {
//membres de B
}

class B

Univ. Alger1/FS/MI DjaafriLyes

 Exemple: Classe PointNommé

Point
 On veut créer une classe
double x représentant un point
double y
nommé à partir de la classe
void afficher()
void deplacer(double dx, double dy) Point=> utilisation de
l’héritage
 Un objet PointNommé est un

PointNommé objet Point a lequel on rajoute

String nom
un attribut nom et une
void afficherPN() méthode AfficherPN()

Univ. Alger1/FS/MI Djaafri Lyes

 Exemple: Classe PointNommé
class PointNommé extends Point { class Point {
private String nom;
private double x, y;
public void afficherPN(){
public void deplacer( double x, double y){
[Link]("Point:"+nom);
this.x = this.x + x;
afficher();
} this.y = this.y + y;

public void setNom(String nom) {[Link]=nom;} }

} public void setX(double x) {this.x=x;}
public void setY(double y) {this.y=y;}
class Test {
public void afficher() {
public static void main(String[] args){
[Link]("["+x+","+y+"]");
PointNommé pn= new PointNommé ();
}
[Link](-4);[Link](3); [Link]("A");
[Link](2,4); [Link](); }

[Link]();
pn
} Affichage:
} x= 0 -4 -2
[-2,7]
y= 0 3 7
Point: A [-2,7] nom= null " A"
 Redéfinition des membres(1/2)
concepts
 La classe héritière peut redéfinir des membres avec le même nom
que la classe mère. Deux cas se présentent :
□ Signature différente et nom identique entre membres classe

fille et classe mère:

=>Il s’agit de cas de surcharge; la classe fille traite les membres redéfinis
comme deux membre de la même classe, on parle de surcharge ou
overloading
□ Signature identique entre méthodes de la classe fille et la
classe mère, on parle de redéfinition ou overriding:
=>Il y a masquage : dans la classe fille , les membres redéfinis
masquent les membres de la classe mère

Univ. Alger1/FS/MI DjaafriLyes

 Redéfinition des membres(2/2)
les contraintes
Java exige les conditions suivantes lors de la redéfinition des méthodes dans une sous classe :
• Le type de retour doit être le même ou une spécialisation du type de retour de la
super-classe.
• La méthode redéfinie dans la sous classe ne doit pas réduire la visibilité de la méthode
définie dans la super-classe.
Exemple:
class A{
… La redéfinition de la méthode
public int f(){..} f() présente deux erreurs de
Réduction de visibilité
… compilation:
• f() dans A est public Type de retour
• f() est redéfinie dans } différent • réduction de la visibilité,
B avec private • changement du type de
class B extend A{
… retour
private void f(){..}
…
}

Univ. Alger1/FS/MI DjaafriLyes

 Redéfinition des membres: exemple
class A{
int q,t;
void f(){..}
void p(int a){..} // visibilité par défaut
int g(){..}
}

class B extends A{
int q; //redéfinition de q dans la sous classe
int g(int a){..} //surcharge de la méthode g()
private void p(int a){..} /*redéfinition non
acceptée- réduction de visibilité*/

void f(){..} /*redéfinition de la méthode f(), donc

} masquage de f() de la super classe*/

Univ. Alger1/FS/MI DjaafriLyes

 Accès au membres masqués
 comment accéder aux membres masqués à l’intérieur d’une sous classe? =>
Utilisation du mot clé super
 super permet d'accéder aux membres de la super classe, de la même manière que l'on
accède aux attributs de la classe elle-même à l'aide du mot-clé this.
 Dans ces conditions, à l’intérieur d’une méthode de la classe B, on a le code suivant:

[Link](q); //attribut q de l’objet en cours déclaré dans B

[Link](super.q); //attribut q de l’objet déclaré dans A
[Link](t); //attribut t déclaré dans A
f(); // <=> this.f(), méthode f() de l’objet b déclaré dans B
super.f(); //méthode f() de l’objet b déclaré dans A
[Link](g()); //méthode g() de l’objet b déclaré dans A
[Link](g(3)); //méthode g(int a) de l’objet b déclaré dans B

Univ. Alger1/FS/MI Djaafri Lyes

 Retour sur la classe PointNommé
class PointNommé extends Point { class Point {
private String nom;
private double x, y;
public void afficherPN(){
afficher()
[Link]("Point:"+nom); public void deplacer( double x, double y){
[Link]();
afficher(); this.x = this.x + x;
} this.y = this.y + y;
public void setNom(String nom) {[Link]=nom;} }
}
public void setX(double x) {this.x=x;}
class Test {
public void setY(double y) {this.y=y;}
public static void main(String[] args){
PointNommé pn= new PointNommé (); public void afficher() {
[Link](-4);[Link](3); [Link]("A"); [Link]("["+x+","+y+"]");
[Link](2,4); }
[Link](); [Link](); }
}
}

• Au lieu d’utiliser afficherPN() on redéfinit la méthode afficher() de Point dans PointNommé

• Réutilisation du code de la méthode afficher() de Point (la super classe) => utilisation de [Link]()
• La méthode afficher() de Point est masquée pour les objets de instances de PointNommé
 Héritage et constructeurs(1/3)
 L’initialisation d’un objet d’une sous-classe implique son initialisation en tant qu’objet de la super-
classe.
 Tout constructeur de la sous-classe commence nécessairement par l’appel d’un constructeur de la
super-classe.
 l’appel du constructeur de la super classe se fait par le biais du mot clé super(…)
 super(…) correspond à un constructeur de la super-classe avec liste d’arguments compatible.

class A{ class B extend A{ class C extend B {

double x; double y; double z;
A(double x){ B(double x, double y){ C(double x, double y, double z){
this.x=x; super(x);// 1ere instruction super(x,y); // 1ere instruction
} this.y=y; this.z=z;
//… } }
} //… //…
} }
c
//…
x= 0 15 C c=new C(15,3,-4);
y= 0 3 //…
z= 0 -4
Univ. Alger1/FS/MI DjaafriLyes
 Héritage et constructeurs(2/3)
 Si aucun appel à un constructeur n’est définie dans la sous classe, alors un appel implicite (sans
écriture de code) au constructeur super() est réalisé par la sous classe

 si aucun constructeur n’est déclaré dans la super-classe alors super() correspond au constructeur par
défaut

class A{ class B extend A{ class C extend B {

double x; double y; double z;
/*constructeur B(double y){ C(double y, double z){
Par défaut*/ super(); // ligne facultative super(y); // 1ere instruction
//… this.y=y; this.z=z;
} } }
//… //…
} }
c
//…
x= 0 C c=new C(3,-4);
y= 0 3 //…
z= 0 -4
Univ. Alger1/FS/MI DjaafriLyes
 Retour sur la classe PointNommé
class PointNommé extends Point { class Point {
private String nom; private double x, y;
public PointNommé (double x, double y, String public Point(double x,double y){
this.x=x; this.y=y;
nom){
}
super(x,y);//la 1ERE instruction
public void deplacer( double x, double y){
[Link]=new String(nom);
this.x = this.x + x;
}
this.y = this.y + y;
public void afficherPN(){
}
[Link]("Point:"+nom); afficher();
public void afficher() {
}
[Link]("["+x+","+y+"]");
} }
class Test { }
public static void main(String[] args){
PointNommé pn= new PointNommé (2,4,"A");
[Link](2,4);
[Link](); [Link]();
}
}
 Héritage & Constructeurs – exemple:

❑ Qu’est ce qu’il affiche ce code class Art {

source java? Art() {
[Link]("Constructeur Art ");
}
❑ Ce code affiche automatiquement: }
class Dessin extends Art {
Dessin() {
Constructeur Art [Link]("Constructeur Dessin");
Constructeur Dessin }
}
Constructeur Cartoon public class Cartoon extends Dessin {
Cartoon() {
[Link]("Constructeur Cartoon ");
}
public static void main(String[] args) {
Cartoon x = new Cartoon();
}
}
 Classes et Méthodes finales
 final devant une Classe : interdire toute final class Point {
//..
spécialisation ou héritage de la classe public void afficher() {
[Link]("["+x+","+y+"]");
concernée
}
Erreur de compilation: héritage interdit
}
 A titre d’exemple la classe String est
class PointNommé extends Point {
final, cela implique qu’elle ne peut
//..
pas être héritée }

class A extends String{

//..
}

Univ. Alger1/FS/MI DjaafriLyes

 Classes et Méthodes finales
class Point {
 final devant une Classe : interdire toute
//..
spécialisation ou héritage de la classe public final void afficher() {
[Link]("["+x+","+y+"]");
concernée
}

 A titre d’exemple la classe String est }

class PointNommé extends Point {
final, cela implique qu’elle ne peut Erreur de compilation :
//..
rdéfinition impossible de afficher()
pas être héritée public void afficher(){
[Link]("Point:"+nom);
 final devant une Méthode : interdire la [Link]();
}
redéfinition d’une méthode dans
}
d’autres classes (des sous classes)

Univ. Alger1/FS/MI DjaafriLyes

 La classe Object
 Une classe qui ne définit pas de clause extends hérite de la classe Object
18 attribut
Object méthodes
 Toute classe hérite directement ou indirectement de la classe Object

Hérite de
 Point hérite directement de Object
 PointNommé hérite indirectement de Object
Point
 La classe Object de la bibliothèque standard de Java est la classe de attributs
méthodes
plus haut niveau dans la hiérarchie d'héritage

Hérite de
Top level Object

… class1 class2
PointNommé
attributs
… class11 class12 class21 méthodes

Univ. Alger1/FS/MI DjaafriLyes

 La classe Object
• Toutes les méthodes contenues dans Objects

Object sont accessibles à partir de Class getClass()

String toString()
n'importe quelle classe car par héritage boolean equals(Object o)
int hashCode()
successif toutes les classes héritent d'Object. …
Point p=new Point();
PointNommé pn=new PointNommé();
[Link](); Point

[Link](..); void deplacer(..)

void afficher()
[Link](..);
[Link]();
[Link]();
PointNommé
.. setCouleur(..)
 Classe Object
La méthode toString()
• La méthode toString() de la classe Object fournit une chaîne
contenant :
– le nom de la classe concernée,
– un code unique de l’objet en hexadécimal (précédé de @).

• Lorsque un objet est passé en paramètre pour la méthode

[Link], il est converti en une chaine de caractère en
lui appliquant la méthode toString
– [Link](o);  [Link]([Link]());

• La méthode toString() de la classe Object est très souvent

redéfinie dans les sous-classes pour obtenir une chaine de
caractère personnalisée
 La classe « Object »: exemple de
redéfinition de méthodes toString()

Object public static void main(String [] args){

redéfinition de
PointNommé p1=new PointNommé(3,5, "x");
[Link](p1);

méthodes
Point
toString() méthode de la classe
Object, affiche :
Avant } P oi nt N ommé @ 1 5 2 b6 6 5 1
PointNommé
println(p1) println([Link]())

class Point {… public static void main(String

redéfinition de méthodes

redéfinition de méthodes
public String toString(){ [] args){
return "("+x+","+y+ ")"; Point p1=new Point(2,-4);
}… [Link](p1);
} //affiche: (2 ,-4)
PointNommé p2;
class PointNommé extends Point { …
public String toString(){
p2=new PointNommé(3,5, "x");
return "Point:" +nom+[Link](); [Link](p2);
//affiche : Point : x(3,5)
Après
}...
} } println([Link]())

Univ. Alger1/FS/MI Djaafri Lyes

 Le mot clé protected (1/2)
 Le modificateur private, appliqué aux membres (champs ou méthodes)
d'une classe, indique que ces champs ne sont accessibles que dans la
classe de définition.
 Même s'il ne sont pas accessibles dans les sous-classes, les attributs
privés sont malgré tout hérités dans les sous-classes (une zone
mémoire leur est allouée).
 Le modificateur protected appliqué aux membres (champs ou
méthodes) d'une classe indique que ces champs ne sont accessibles
que dans la classe de définition, dans les classes du même paquetage
et dans les sous-classes de cette classe (indépendamment du
paquetage).

Univ. Alger1/FS/MI DjaafriLyes

 Le mot clé protected (2/2)

class A {
private int x;
protected int y;
}

class B extends A {
x=1; // erreur de compilation: x est private dans la super-classe
y=1; //correcte: y est protected dans la super-classe
}

Univ. Alger1/FS/MI DjaafriLyes

 Polymorphisme
surclassement

 Une classe B qui hérite de la classe A peut

être vue comme un sous-type (sous
ensemble) du type défini par la classe A Point

□ Le type PointNommé est un sous ensemble du

PointNommé
type Point
□ L’ensemble des PointNommé est inclus dans
l’ensemble des Point.

Univ. Alger1/FS/MI DjaafriLyes

 Polymorphisme
surclassement
 Une instance de B peut donc être vue comme (Type A)
instance de la super classe de B qui est la classe A a
A
 Cette relation est directement supportée par le Objet
langage JAVA : instance
de B
□ à une référence déclarée de type A il est B
possible d'affecter une valeur qui est une
référence vers un objet de type B A a = new B();
(surclassement ou upcasting),
Exemple:
Object
PointNommé pn = new PointNommé(…);
(Type Point)
Point p = pn;
Point p
Point p = new PointNommé(…);
Point p = new PointColoré(…);✓ x=1.5
Object o = new Point(…);
✓ Objet
y=2.3 instance de
✓
Object o = new PointNommé(…); PointNommé
nom="x"
PointNommé PointColoré
Object o = new PointColoré(…);✓
✓
Univ. Alger1/FS/MI DjaafriLyes
 Polymorphisme
surclassement

Question: comment se comporte

java avec le surclassement?

Univ. Alger1/FS/MI DjaafriLyes

Polymorphisme
surclassement
Type1 Type2
(super classe) (sous classe)

Avec le surclassement ref1 = ref2; ref1.f(..); java réalise deux vérifications

 À la compilation: Les méthodes autorisées sont seulement celles proposées par la
super classe- Type2 (f doit être proposé dans le type de la référence ref1)
 Lors de l’exécution: on recherche la méthode f à partir de la classe correspondant
au type effectif de l’objet référencé par ref1 , si cette classe ne comporte pas de
méthode f, on remonte dans la hiérarchie jusqu’à ce que l’on retrouve (au pire, on
remontera jusqu’au Type1).
A
f() g()
Cas de surclassement possibles:
A a; C c;
B C C c=new C(); c=new D();//c surclassé
f() g() q() a=c; c=new E();
a=new B(); c=new A();
a=new E(); c=new B();
D E a=new D();
g()
 Polymorphisme
surclassement
class Point {
class GroupePoint{
double x,y; public static void main(String[] args){
public Point(..){..}
public void deplacer(){..} Point[] tabPoint=new Point[3];
public void afficher() {
[Link]("["+x+","+y+"]"); tabPoint[0]=new PointColoré(2,1,"bleu");
}
}
tabPoint[1]=new PointNommé(2.5,4.8,"A");
tabPoint[2]=new Point(-1,2);
for(int i=0; i<[Link]; i++){
tabPoint[i].setCoul("rouge");
class PointNommé extends Point {
String nom; tabPoint[i].setNom("B");
public PointNommé(..){..}
public void afficher() { tabPoint[i].deplacer(2,2);
[Link](); tabPoint[i].afficher();
[Link]("Je suis le point:"+ nom);
} } tabPoint[0].afficher();
public setNom(String nn){nom=nn;}
} } tabPoint[1].afficher();
} tabPoint[2].afficher();

class PointColoré extends Point {

String coul; tabPoint
public PointColoré(..){..} 0 1 2
public void afficher() {
[Link]();
[Link]("ma couleur est:"+ coul);
} x= 3.0 x= 3.0 x= -1.0
public setCoul(String nc){coul=nc;} y= -1.0 y= -1.0 y= 2.0
} Coul="bleu nom= "A"
"
 Polymorphisme
surclacement- interêt

❑ En proposant d'utiliser un même nom de méthode pour

plusieurs types d'objets différents, le polymorphisme permet
une programmation beaucoup plus générique.

❑ Le développeur n'a pas à savoir, lorsqu'il programme une

méthode, le type précis de l'objet sur lequel la méthode va
s'appliquer. Il lui suffit de savoir que cet objet implémentera la
méthode.[wikipedia]

Univ. Alger1/FS/MI Djaafri Lyes

Polymorphisme
sousclassement
❑ Avec le surclassement , seules les méthodes de la super classe sont
autorisées
❑ Si un objet surclassé veut utilisé une méthode définie dans la sous classe
alors il faut utiliser le sous-classement.
❑ Le sous-classement force un objet à « libérer » les fonctionnalités
(méthodes) cachées par le surclassement
❑ Comment ? => Conversion de type explicite (cast), même syntaxe du
cast en types prémitifs.

Univ. Alger1/FS/MI Djaafri Lyes

 Polymorphisme
Sousclassement

A A a; « a » est une référence de type A==>

« a » peut invoquer seulement des
void f() a=new B(); méthodes de la classe A. : void g() et
void g() void f()
a.q();
surclassement de l’objet «a »
a référence réellement un
objet de type B.
B B b=(B)a;
void f() b.q(); erreur : méthode cachée par
void q() le surclassement
//ou
sous classement
Sous classement de a ((B)a).q(); de l’objet« b »
et appel de la méthode q() méthode libérée par
le sousclassement
Univ. Alger1/FS/MI Djaafri Lyes
Polymorphisme
Sousclassement- exemples
Object o=new String("abc");
char a=[Link](1);//erreur, chartAt n’est une méthode de Object
String s=(String)o; // sous-classement : conversion explicite
a=[Link](1); //traitement de s
//ou
a=((String)o).charAt(1);

Point p=new PointNommé(-3,5,"a");

[Link]("b");//erreur, setCouleur() n’est une méthode de Point
PointNommé pn=(PointNommé)p; // sous-classement : conversion explicite
[Link]("b");
// ou
((PointNommé)p).setNom("b");

Univ. Alger1/FS/MI Djaafri Lyes

 Polymorphisme
conclusion: surclassement & sousclssement
Point p;
PointNommee pn = new PointNommee(3, -4, a );

p = pn; // OK. Généralisation : conversion implicité

pn = p; // ERREUR de compilation

pn = (PointNommee ) p; // OK. Spécialisation: conversion

explicite

Univ. Alger1/FS/MI Djaafri Lyes

Polymorphisme
L’opérateur instanceof
L’opérateur instanceof est utilisé pour vérifier si un objet est une
instance d’un type donné ou pas. Il retourne true ou false.
Syntaxe:
(objet) instanceof (type)
Exemple:

Point p= new Point();

[Link](p instanceOf Point);// true Point p1;
p= null;
[Link](p instanceOf Point);// false : p est null

Univ. Alger1/FS/MI Djaafri Lyes

Polymorphisme
L’opérateur instanceof et le sous classement
class TestConversionObjet{

public static void sousClassement(Point p){

if(p instanceof PointNommé) {
PointNommé pn=(PointNommé)p;
[Link]("sous classement possible");
//suite du traitement
} else
[Link]("sous classement impossible");
}

public static void main(String[] args){

Point p= new Point(); sousClassement(p); //sous classement impossible
Point pn= new PointNommé(); sousClassement(pn); //sous classement possible
}
}

Univ. Alger1/FS/MI Djaafri Lyes

 Polymorphisme
redéfinition de la méthode equals
Object public class Point {
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
protected boolean equals(Object o)
Point p= (Point)o;
…
return (this.x == p.x && this.y== p.y);
}
}

Point
public class TestOverrideEquals {
public boolean equals(Object o) public static void main(String [] args) {
…
Point p1,p2,p3,p4=null; p1=new Point(3,4);
p2=new Point(3,4); p3=new Point(3,-10);
String s="Bonjour";
[Link]("p1 égale à p2 :"+[Link](p2));
[Link]("p1 égale à p3 :"+[Link](p3));
[Link]("p1 égale à p4 :"+[Link](p4));
[Link]("p1 égale à s :"+[Link](s));
}
}

Univ. Alger1/FS/MI Djaafri Lyes