java héritage et polymorphisme

1. CHAPITRE 4
HÉRITAGE ET POLYMORPHISME

2. 1. Relation d’héritage entre classes
Le concept de l’héritage spécifie une relation de spécialisation/généralisation entre les classes.
(Document : Livre, Revue, … | Personne : Etudiant, Employé, …)
Lorsqu’une classe A hérite d’une classe B :
A possède toutes les caractéristiques de B et en plus ceux spécifiques à A
A est une spécialisation de B (A est un cas particulier)
B est une généralisation de A (B est un cas général)
A est appelée classe dérivée (fille ou sous-classe)
B est appelée classe de base (mère ou superclasse)
Tout objet instancié de A est considéré, aussi, comme un objet de type B
Un objet instancié de B n’est pas forcément un objet de type A.
Une classe peut hériter de plusieurs classes : héritage multiple
Une classe de base peut être héritée par plusieurs classes
L’héritage minimise l’écriture du code (par réutilisation) et favorise l’extension.
1.1. Héritage en Java
La classe Object est la classe mère de toutes les classes en Java (même sans l’indiquer).
Object comporte uniquement des méthodes et elle est définie dans le package java.lang de
l’API Java.
Tout objet est implicitement de type Object.
L’héritage multiple est interdit en Java (possible avec les interfaces).
Héritage Simple Héritage Multiple
En Java, l’héritage est une sorte d’extension des classes : on utilise « extends »
public class A extends B { //La nouvelle classe A hérite de B
…
}

3. Une référence d’objet de type B peut référencer un objet de type A, mais l’inverse est
faux.
Exemple :
class B { …………… }
class A extends B {………………}
B b = new B() ;
A a = new A() ;
b=a; //correct
a=b; //incorrect
1.2. Constructeur de la classe dérivée
Le constructeur de la classe de base est appelé par le constructeur de la classe dérivée
lorsque ce dernier utilise super ( ).
Le nombre de paramètres dans super() identifie le constructeur à appeler dans la classe
mère.
L’instruction super() doit être la première dans le constructeur de la classe fille.
Si dans le constructeur de la classe dérivée, on ne fait pas appel à super (), alors Java
appelle implicitement le constructeur par défaut de la classe de base (implicite ou
explicite).
Exemple :
class Point {
private int abs, ord; //deux attributs privées
public Point(int a, int b){
abs = a;
ord = b;
}
}
class PointColore extends Point {
private String couleur;
public PointColore (int a, int b, String c) {
super (a, b); //appel au constructeur de la classe mère (public)
couleur = c;
System.out.println("abs et ord sont :" + super.abs + "et" + super.ord) ;
//Erreur, car abs et ord sont privés à la classe mère, donc invisible pour la classe fille.
}
}

4. Lors de la construction d’une instance dérivée, les opérations de construction de la classe
mère sont successivement appelées.
PointColore pc = new PointColore (1,2,"noir");
//appel de consructeur de Point puis appel de Constructeur de PointColore
Remarques :
Si les deux classes mère et fille ne possèdent aucun constructeur, le constructeur par
défaut de la classe fille appelle le constructeur par défaut de la classe de base.
Si la classe fille ne possède pas de constructeur, alors le constructeur par défaut de la
classe fille cherche à appeler un constructeur par défaut (sans arguments) de la classe
mère. Si ce dernier n’existe pas alors on obtient une erreur de compilation.
1.3. Accès aux membres hérités par « protected »
Le modificateur d’accès protected peut être utilisé dans la classe de base.
Les attributs et méthodes déclarées protected dans la classe de base sont accessibles
(peuvent être utilisés) par les classes dérivées. Mais, cet accès reste interdit pour les autres
classes qui ne sont pas dérivées.
Exemple:
class Point {
protected int abs, ord; //deux attributs protégés
public Point(int a, int b){
abs = a;
ord = b;
}
}
class PointColore extends Point {
private String couleur;
public PointColore (int a, int b, String c) {
super (a, b); //appel au constructeur de la classe mère
couleur = c;
System.out.println("abs et ord sont :" + super.abs + "et" + super.ord) ;
//accès autorisé à abs et ord, ils sont accessibles par les méthodes des classes filles
}
}

5. Remarques :
Lorsque les attributs abs et ord de la classe Point sont déclarés protégés, alors ils sont
considérés aussi des attributs de la classe PointColore. On peut alors les accéder aussi bien
par super que par this. ( super.abs ou this.abs donnent le même résultat)
Si on déclare un attribut abs dans PointColore alors dans ce cas, this.abs fait référence à
l’attribut de PointColore et super.abs fait référence à l’attribut de Point.
Exemple:
class Point {
...
protected void afficher(){
System.out.println(“abs = ” + abs + “ord = ” + ord);
}
}
class PointColore extends Point {
...
public void afficherCouleur(){
System.out.println(“couleur = ” + couleur);
}
}
...
public static void main(String args[]) {
PointColore pc = new PointColore (1, 2, “noir”);
pc.afficher() ; //objet pc utilise afficher() de Point comme si c’était sa méthode
pc.afficherCouleur() ;
}
Dans cet exemple, l’affichage de tous les attributs d’un PointColore doit passer par l’appel de
la méthode afficher() de Point et afficherCouleur() de PointColore.
La méthode afficher() de Point est partiellement utile à PointColore. On pourra ajouter une
méthode void afficher() à la classe PointColore et ainsi ne plus utiliser celle de Point : on
appelle ça la redéfinition de méthode.
2. Redéfinition des méthodes héritées
Une méthode héritée peut être redéfinie si sa version initiale n’est pas satisfaisante pour la
classe dérivée.
La redéfinition consiste à conserver la signature de la méthode (même nom, même
nombre, type et position des paramètres, même type de retour) et à proposer un code
différent.

6. Lors de la redéfinition d’une méthode, l’appel de l’ancienne version (celle de la classe de
base) est possible par super.nom_méthode(), et ce dans l’endroit du nouveau code que le
programmeur juge adéquat.
Si une méthode héritée est redéfinie, c’est uniquement la nouvelle version qui fait partie
de la description de la classe dérivée.
Exemple:
class PointColore extends Point {
...
public void afficher() { //redéfinition de la méthode afficher()
super.afficher() ; //appel de afficher () de la classe mère
System.out.println("Couleur = " + couleur) ;
}
Public String toString() //redéfinition de la méthode toString() de Object
return ("Abscisse = " + super.abs + "Ordonnée = " + super.ord + "Couleur
= " + couleur) ;
}
3. Classes et méthodes finales
Java permet d’interdire l’héritage d’une classe en la déclarant avec le modificateur
« final »
Exemple:
final class Point { //interdire d’hériter de cette classe
...
}
class PointColore extends Point { //Erreur levée à ce niveau (cannot inherit from
final Point)
...
}
Java permet d’interdire la redéfinition d’une méthode (si elle est héritée) en la déclarant
avec le modificateur « final »
Exemple:
class Point {
...
final protected void afficher(){ //interdire la redéfinition de cette méthode
...
}
}

7. class PointColore extends Point {
...
public void afficher(){
super.afficher();//Erreur levée à ce niveau (afficher() in PointColore cannot
... } override affciher() in Point, Overridden method is final )
4. Surcharge des méthodes et héritage
La surcharge c’est la définition, au sein d’une même classe, de plusieurs méthodes
portant le même nom mais qui sont différents au niveau des paramètres (type, ordre et
nombre d’arguments) ou au niveau du type de retour.
Exemple:
class Point {
...
public void deplacer (int a, int b){ ...}
public void deplacer (){ ...}
}
}
En java, une classe dérivée peut surcharger une méthode d’une classe ascendante.
La recherche d’une méthode acceptable ne se fait qu’en remontant la hiérarchie
d’héritage, jamais en la descendant.
Exemple:
class A {
...
public void f (int n){ ...}
}
}
class B extends A {
...
public void f (float x){ ...}
}
}
A a ; B b ;
int n; float x ;
...
a.f(n) ; //appelle f(int) de A
a.f(x) ; //erreur de compilation
b.f(n) ; //appelle f(int) de A
b.f(x) ; //appelle f(float) de B

8. 5. Références d’objets en héritage
Une référence d’une classe de base peut désigner un objet d’une classe dérivée.
L’opérateur de Casting peut être utilisé pour convertir une référence déclarée de type
classe de base en une référence de type classe dérivée (pour un objet de la classe dérivée).
Exemple:
public static void main(String[] args) {
PointColore pc;
Point p1, p2;
p1 = new PointColore (1,2,"noir"); //Point fait référence à un PointColore
p1.afficher();//afficher () de PointColore qui est appelée
// pc = p1 ; //Erreur car types incompatibles
pc =(PointColore) p1; //Cating (convertir p1 de Point en PointColore pour
pouvoir affecter sa référence dans pc)
p2 =pc; //p1, p2 et pc désignent le même objet
}
Un objet de type classe de base peut stocker la référence d’un objet de type classe dérivée.
Mais l’inverse n’est pas autorisé. Pour le faire il faut passer par le casting.
6. Le polymorphisme
6.1. Les méthodes polymorphes
Une méthode polymorphe est une méthode déclarée dans une super-classe et redéfinie par
une sous-classe.
Les méthodes polymorphes permettent de prévoir des opérations similaires sur des objets
de natures différentes
Les méthodes « final » ne peuvent être redéfinies et ne sont donc pas polymorphes.
6.2. Définition du polymorphisme
Il s’agit d’invoquer (appeler) des méthodes sans connaitre la nature de l’objet
correspondant
L’appel se fait à partir d’une référence du même type que l’objet correspondant ou de type
sa classe de base. (on peut remonter à tous les niveaux de sa classe de base)

9. Un mécanisme dynamique permet de déterminer, au moment de l’exécution, laquelle des
méthodes à invoquer selon la nature de l’objet référencé (gestion d’un pointeur sur la
description de la classe de l’objet)
Le polymorphisme favorise la propriété d’extension des applications.
Exemple:
class Personne
{ ...
public void quiEtesVous() { System.out.println(“personne”); }
}
class Etudiant extends Personne
{ ...
public void quiEtesVous() { System.out.println(“etudiant”); }
}
class Employe extends Personne
{ ...
public void quiEtesVous() { System.out.println(“employé”); }
}
public class Population
{ ...
public static void main(String args[]) {
Personne pop[] = new Personne [3];
pop[0] = new Etudiant() ;
pop[1] = new Personne () ;
pop[2] = new Employe () ;
for( int i =0; i<3; i++)
pop[i].quiEtesVous() ; //appel polymorphe
}
}
7. La super classe Object
Il existe une classe nommée Object dont dérive implicitement toute classe simple.
Une variable de type Object peut être utilisée pour référencer un objet de type quelconque
La classe Object dispose de quelques méthodes qu’on peut soit utiliser telles quelles, soit
redéfinir. Les plus importantes sont toString() et equals().
La méthode toString() de la classe Object fournit une chaine contenant le nom de la classe
concernée et l’adresse de l’objet en hexadécimal.
La méthode equals() de la classe Object se contente de comparer les adresses de deux
objets concernés.

10. 8. Exercices
Exercice 1 :
Une entreprise engage trois types d’employés à savoir : Des contractuels (travaillants pour un
contrat à durée déterminée), des permanents et des vacataires (travaillants par heure). Pour
chacun de ces employés, l’entreprise retient les informations suivantes : nom, num CIN,
adresse et salaire.
Les vacataires sont payés mensuellement en fonction du nombre d’heure effectué pendant le
moi et du prix de l’heure. Les contractuels sont payés par mois, ils reçoivent un salaire de
base. Les permanents sont payés mensuellement un salaire de base en plus d’une prime de
rendement. Un service de calcul de salaire est prévu pour chaque type d’employé.
1. Schématiser la relation d’héritage entre les classes : Employe, Vacataire, Contractuel et
Permanent. (indiquer les attributs et les méthodes)
2. Définir la classe mère Employe :
- Les champs sont : nom, CIN, adresse et salaire
- Une méthode afficher()
3. Définir les autres classes filles sachant que chacune contient :
- Les attributs nécessaires pour calculer le salaire
- Une méthode calculSalaire()
- Une méthode afficher()
4. dans le programme principal, créer un vecteur qui contient trois employés de types
différents et les afficher.
Exercice 2 :
Soit la classe Test suivante. Dites si les instructions 1 à 8 sont valides ou non. En cas d’une
instruction non valide, préciser s’il s’agit d’une erreur de compilation ou d’exécution.
class Test {
public static void main (String args[]){
C1 o1 = new C1();
C1 o2 = new C11();
C111 o3 = new C111();
C11 o4 = new C111();
C1 o5 = new C111();
o1 = o2; //instruction 1
o1 = o3; //instruction 2
o3 = o1; //instruction 3
o4 = o5; //instruction 4
o3 = (C111) o1; //instruction 5
o4 = (C11) o5; //instruction 6
o4 = (C111) o2; //instruction 7
o3 = (C11) o5; //instruction 8
}
}
class C1 {}
class C11 extends C1 {}
class C111 extends C11 {}

11. Exercice 3 :
1. Ecrire une Classe Point avec les attributs suivants : x : l’abscisse, y : l’ordonnée. La classe
Point doit disposer des constructions suivantes : Point(), Point(x,y)
La classe Point doit contenir les accesseurs et mutateurs et aussi une méthode toString()
donnant une représentation du point.
2. Ecrire une classe Rectangle héritant de Point avec les attributs suivants : longueur,
largeur. La classe rectangle doit disposer des constructeurs suivants : Rectangle(),
Rectangle (x,y, longueur, largeur)
La classe Rectangle doit contenir des accesseurs et mutateurs et aussi les méthodes
suivantes : aire() ; donne l’aire du rectangle, toString() : donne une représentation du
rectangle (redéfinition)
3. Ecrire une classe Parallélogramme héritant de Rectangle avec l’attribut hauteur. La classe
Parallélogramme doit disposer des constructeurs suivants : Parallélogramme(),
Parallélogramme (x, y, longueur, largeur, hauteur)
La classe Parallélogramme doit contenir des accesseurs et des mutateurs et aussi les
méthodes suivantes : aire() : donne l’aire du parallélogramme (redéfinition), volume() :
donne le volume du parallélogramme, toString() : donne une représentation du
parallélogramme (redéfinition).
4. Ecrire une classe de test afin de tester les classes.