Héritage

On a parfois besoin de définir un type d’objet similaire à un type existant avec quelques propriétés
supplémentaires. L’héritage permet de définir ce nouveau type sans tout programmer. Il suffit de
déclarer que le nouveau type hérite du précédent et on se borne à rédiger ses fonctionnalités
supplémentaires. Ceci constitue l’utilisation la plus simple de l’héritage. L'héritage est donc un
mécanisme de transmission des propriétés (attributs et méthodes) d'une classe de base vers une
sous-classe. La relation d’héritage est une relation de généralisation / spécialisation. En d'autres
termes, cet outil permet de déclarer des classes très générales, puis progressivement "spécialiser"
ces classes. Cette spécialisation est aussi une "extension" ou une "dérivation" de la classe de base.

Plutôt que de réimplémenter des fonctionnalités existantes déjà dans une classe A, une classe B peut
intégrer des données et fonctions de la classe A.
On dit :
- B est un A;
- B hérite de A;
- B dérive de A;
- B est une sous classe de A;
- B est une classe fille de A;
- A est la classe de base ou la classe mère ou la superclasse.

Pour construire la classe B, le compilateur va devoir d’abord créer la classe A. Il va donc appeler un
constructeur de la classe A. Puis il va appeler celui de B.
Pour définir une classe B qui dérive de la classe A, on utilise le mot clé extends dans la déclaration
du type:

class B extends A { ... }

il s'agit d'indiquer, dans la sous-classe B, le nom de la superclasse A dont elle hérite.

Un objet de la classe B est alors aussi un objet de la classe A, il peut être utilisé partout où un objet
de la classe A est attendu.
On peut tester l’appartenance d’un objet à une classe grâce `a l’opérateur instanceof, comme dans
l’exemple qui suit :

Module Java M2/ESE Dr Kemmouche

 B x;
if ( x instanceof A)
System.out.println(‘‘x est aussi un objet A !’’);

L’exécution des lignes précédentes provoque l’affichage de “x est aussi un objet A !”.
Si l’on définit un constructeur d’une classe dérivée, celui-ci doit explicitement faire appel `a un
constructeur de la classe mère, auquel on accède avec la méthode prédéfinie super ( ... ). Si cet
appel explicite n’est pas fait, l’exécution du programme provoquera un appel implicite du
constructeur par défaut.
L’appel explicite du constructeur de la classe mère par la méthode prédéfinie super ( ... ), est
obligatoirement la première instruction du constructeur. On ne peut donc transmettre que des
valeurs de paramètres du constructeur courant lors de l’appel de super ( ... ).
Par exemple, on peut créer un nouveau type "Fonctionnaire" à partir d’un type plus général
"Personne" :
La notation class Fonctionnaire extends Personne {…} indique que la classe Fonctionnaire hérite
de la classe Personne. On dit également que la classe Fonctionnaire est une classe dérivée de la
classe Personne ou une sous-classe ou une classe fille. Personne est une classe de base de
Fonctionnaire ou une classe mère. Le type Fonctionnaire possède toutes les propriétés du type
Personne, mêmes composantes (données et méthodes), plus quelques nouveaux composantes par
exemple les attributs salaire et Fonction et la méthode CaculPprime ( ).
Les structures des deux classes Personne et Fonctionnaire sont :

Héritage : représentation avec UML d’un héritage simple

Personne
- Nom : string
- Prenom : string Superclasse
- Age : int
- SePresenter
Lien d’héritage

Fonctionnaire Sous-classe
- fonction: string
- salaire : double

- CalculPrime

Module Java M2/ESE Dr Kemmouche

La classe Fonctionnaire a des attributs comme ceux de la classe Personne en plus de ses propres
attributs. Dans la création de la classe fille Fonctionnaire, on ne déclare que ses attributs qu’on met
en premier dans le constructeur de la classe fille.
Grâce à l’héritage, la classe Fonctionnaire récupère automatiquement tous les attributs et toutes les
méthodes de la classe Personne. Ainsi, la classe Fonctionnaire possède 5 attributs (Nom, Prenom,
Age, salaire, fonction) et 2 méthodes à savoir :
• une méthodes dont elle hérite : SePresenter( )
• une méthode qui lui est propre : CalculPrime( )
La définition de la classe Fonctionnaire, ressemble à ceci :

public class Fonctionnaire extends Personne

{
private String Fonction ;
private int Salaire;

public Fonctionnaire (String F, int S, String N, String P, String D)

{
super (N, P, D);
Fonction = F;
Salaire = S;
} // end du constructeur de la classe fille Salaire
public CalculPrime ( )
{
.. .
}
} //end de la classe fille Salaire

L’utilisation répétée de l’héritage sur des classes successives conduit à la construction d’une
hiérarchie entre elles, que l’on peut schématiser par un arbre d’héritage. La figure ci-dessous
présente un exemple d’arbre d’héritage construit sur des classes permettant de représenter des
figures géométriques.

Figure

Polygone Cercle

Triangle Rectangle

Exemple d'arbre d'héritage

Module Java M2/ESE Dr Kemmouche