III.

Hritage & polymorphisme

III.1 Heritage

Une classe qui hrite d'une autre est une sous classe et celle
dont elle hrite est une super classe. L'hritage successif de
classes permet de dfinir une hirarchie de classe qui se
compose de super classes et de sous classes.

En utilisant l'hritage, les objets d'une classe ont accs aux

donnes et aux mthodes de la classe parent ce qui facilite la
rutilisation du code.

 Les sous classes peuvent redfinir les variables et les mthodes

hrites.
Une classe peut avoir plusieurs sous classes. Une classe fille (sous
classe) ne peut avoir qu'une seule classe mre (super classe): il n'y a

pas d'hritage multiple en java (mais existe dans d`autres langages

OO)
Object est la classe mre de toutes les classes en java. Toutes les

variables et mthodes contenues dans Object sont accessibles

partir de n'importe quelle classe car par hritage successif toutes les
classes hritent d'Object.
On utilise le mot cl extends pour indiquer qu'une classe hrite d'une
autre.

Exemple

public class Point{

int x,y;
public Point(int a, int b){
x=a; y=b;
}
public void afficher(){
System.out.println(x+`` ``+y);
}
}
public class Pointcol extends Point{
String color;
public void decolorer(){
color=white;
}
}

A. Construction des objets drivs

Le constructeur de la classe drive doit prendre en charge lintgrit

de la construction de lobjet. si les attributs de la classe de base sont
privs (encapsuls), il faudrait utiliser un constructeur de la classe de
base, et dans ce cas, il faut que a soit la premire instruction du
constructeur et ce dernier est dsign par le mot SUPER. Dans le cas
des drivations successives, super dsigne le constructeur de la
classe de base immdiatement suprieure.

Exemple1
Class A {public A(){} //constructeur1 de A
public A(int n){} //constructeur2 de A
}
Class B Extends A{..//pas de constructeur}
B b=new B(); //Appel du constructeur 1 de A

Exemple2
Class A { public A(int n){} //constructeur2 A seulement }
Class B Extends A{..//pas de constructeur}
B b=new B();
//Erreur de compilation

Exemple3
Class A {..//pas de constructeur}
Class B Extends A{..//pas de constructeur}
B b=new B(); //le constructeur par dfaut de B qui appel le
constructeur par dfaut de A

Exemple
Class Pointcol Extends Point
{
Public void affiche(){
affiche(); //appel rcursif (super.affiche() appel affiche() de la classe de base)
System.out.println( . );
}
}

 Surdefinition/surcharge: dune mthode lintrieur dune

mme classe correspond des mthodes de mme nom mais de

signatures diffrentes.

Redfinition: une classe drive peut redfinir une mthode

dune classe ascendante c..d un code diffrent pour une
mthode de mme nom et mme signature.

B. Redfinition et drivations successives:

A*
de A

de D

D*

de A

de A
C*

de C

de C

C. Surdefinition et hritage:
la recherche dune mthode acceptable ne se fait quen remontant
la hirarchie dhritage, jamais en descendant.

Class A { public void f(int n){}}

Class B extends A {public void f(float x){}}
Aa; Bb;
Int n; float x;
a.f(n) //f de A
a.f(x) // erreur de compilation (car on peut pas convertir float->int)
b.f(n) //f de A
b.f(x) //f de B

III.2

Polymorphisme

A*

Affectations lgales
a=b;a=c;a=d;a=e;a=f;b=d; b=e;c=f;
Affectations illgales
b=a; d=c; c=d;

de D

de A

D*

de A

de A
C*

A. Polymorphisme, redfinition et surdefinition

Class A {public void f(float x){.}.}
Class B extends A {public f(float x){} //redefinition
public f(int n) //surdefinition }
A a = new A(); B b=new B();
a.f(n) // f(float) de A

b.f(n) // f(int) de B

a=b;

a.f(n) // f(float) de B

de C

de C

B. Conversions des arguments effectifs: lors de lappel dune

mthode, ses arguments effectifs peuvent tre soumis des
conversions implicites, ces derniers peuvent galement intervenir dans
la recherche dune fonction surdefinie.
Mthode non surdefinie
Class A {
public void identit(){system.out.println(objet de type A);}}
Class B extends A{//sans surdefinition de Identit}
Class Util{static void f(A a){a.identit();}}
A a= new A();
B b = new B();
Util.f(a); //appel usuel
Util.f(b); //conversion de la rfrence de type B en rfrence de type A
Avec:
Class B Extends A{ Public void identit {system.out.println (je suis B);}}
Util.f(b) //conversion de b en a mais appel de identit de B

 Mthode surdefinie
On suppose que la conversion int->float est possible et float->int ne
lest pas.
Class A{ }
Class B extends A { }
Class Util { static void f(int p, B b) {.}
static void f(float x, Aa){..}}
Exemple1
A a= new A(); B b=new B();
Int n; float x;
Util.f(n,b) // OK sans conversion, appel de f(int,B)
Util.f(x,a) // OK sans conversion, appel de f(float,A)
Util.f(n,a) // conversion n en float, appel de f(float,A)
Util.f(x,b) // conversion b en A, appel de f(float,A)

Exemple2
Class A{.}
Class B Extends A {..}
Class Util { static void f(int p, A a){..}
static void f(float x, B b){..}}
A a =new A();
B b=new B();
Int n; float x;

Util.f(n,a); // OK sans conversion f(int,A)

Util.f(x,b); // OK sans conversion f(float,B)
Util.f(n,b); // Erreur de compilation (cas ambigu)
Util.f(x,a); // Erreur de compilation (aucune conversion possible)