COURS JAVA

CHAPITRE V: HERITAGE, POLYMORHISME, CLASSE

ABSTRAITE ET INTERFACE

V.1. HERITAGE

L'héritage est un mécanisme qui permet à une classe d'hériter de l'ensemble du comportement
et des attributs d'une autre classe.

Grâce à l'héritage, une classe peut disposer immédiatement de toutes les fonctionnalités d'une
classe existante. De ce fait, pour créer la nouvelle classe, il suffit d'indiquer dans quelle
mesure elle diffère de la classe existante.

Une classe qui hérite d'une autre classe est appelée sous-classe ou classe dérivée, et la classe
qui offre son héritage à une autre est appelée super-classe, ou classe de base.

Chaque classe ne peut posséder qu'une super-classe, mais elle peut avoir un nombre illimité
de sous-classes. Les sous-classes héritent de tous les attributs et de l'ensemble du
comportement de leur super-classe.

Dans l'exemple ci-contre, deux sous-classes sont créées, à savoir Chien et Oiseau. Elles
héritent toutes les deux de la super-classe Animal et à ce titre elles récupèrent tous les
attributs et tout le comportement de cette dernière. Par exemple Chien et Oiseau sont tous les
deux capables de Manger. Par contre Chien n'est pas capable deVoler, ce comportement n'est
valable que pour Oiseau.

Dans la pratique, cela signifie que si la super-classe possède un comportement et des attributs
dont vous avez besoin, il ne sera pas nécessaire de la redéfinir ou d'en copier le code pour
disposer du même comportement et des mêmes attributs dans votre classe. Votre classe
recevra, en effet, automatiquement ces éléments de sa super-classe, la super-classe les recevra
de sa propre super-classe, et ainsi de suite, jusqu'au sommet de la hiérarchie. Votre classe
deviendra une combinaison de toutes les caractéristiques de classes situées au-dessus d'elle
dans la hiérarchie, ainsi que de ses propres caractéristiques.

FONKE Eric 1
 COURS JAVA

La partie supérieure de la hiérarchie de classes est occupée par la classe Object ; toutes les
classes héritent des attributs et du comportement de cette super-classe. La classe Object est la
classe la plus générale de la hiérarchie. Cette classe est implicite, elle existe
systématiquement. Elle définit le comportement et les attributs dont héritent toutes les classes
de la bibliothèque de classes de Java. Au fur et à mesure que l'on descend dans la hiérarchie,
chaque classe devient plus adaptée à une tâche précise. Une hiérarchie de classes définit des
concepts abstraits en haut de la hiérarchie. Ces concepts deviennent de plus en plus concrets
et spécialisés au fur et à mesure que l'on descend dans la hiérarchie des sous-classes.

FONKE Eric 2
 COURS JAVA

V .1.1 Notion d’héritage

Nous allons voir comment mettre en œuvre l'héritage en Java, à partir d'un exemple simple de
classe ne comportant pas encore de constructeur. Supposez que nous disposions de la
classe Point suivante :

 Classe de base :

FONKE Eric 3
 COURS JAVA

 La classe dérivée

 Classe executable :

FONKE Eric 4
 COURS JAVA

V .1.2 Accès d’une classe dérivée aux membres de sa classe de base

En introduction, nous avons dit qu'une classe dérivée hérite des champs et méthodes de sa
classe de base. Mais nous n'avons pas précisé l'usage qu'elle peut en faire. Voyons
précisément ce qu'il en est en distinguant les membres privés des membres publics.

V .1.3. Une classe dérivée n’accède pas aux membres privés

Dans l'exemple précédent, nous avons vu comment les membres publics de la classe de base
restent des membres publics de la classe dérivée. C'est ainsi que nous avons pu appliquer la
méthode initialise à un objet de type Pointcol.

En revanche, nous n'avons rien dit de la façon dont une méthode de la classe dérivée peut
accéder aux membres de la classe de base. En fait, une classe dérivée n'a pas plus de droits
d'accès à sa classe de base que n'importe quelle autre classe :

Cette règle peut paraître restrictive. Mais en son absence, il suffirait de créer une classe
dérivée pour violer le principe d'encapsulation.

Si l'on considère la classe Pointcol précédente, elle ne dispose pour l'instant que d'une
méthode affiche, héritée de Point qui, bien entendu, ne fournit pas la couleur. On peut
chercher à la doter d'une nouvelle méthode nommée par exemple affichec, fournissant à la
fois les coordonnées du point coloré et sa couleur. Il ne sera pas possible de procéder ainsi :

En effet, la méthode affichec de Pointcol n'a pas accès aux champs privés x et y de sa classe
de base.

V .1.4. Une classe dérivée accède aux membres publics

FONKE Eric 5
 COURS JAVA

Comme on peut s'y attendre :

Une méthode d'une classe dérivée a accès aux membres publics de sa classe de base.

Ainsi, pour écrire la méthode affichec, nous pouvons nous appuyer sur la
méthode affiche de Point en procédant ainsi :

On notera que l'appel affiche() dans la méthode affichec est en fait équivalent
à this.affiche(); Par héritage, la méthode affiche fait partie de la sous-classe.

Nous pouvons procéder de même pour définir dans Pointcol une nouvelle méthode
d'initialisation nommée initialisec, chargée d'attribuer les coordonnées et la couleur à un point
coloré :

V .1.5. Une classe dérivée accède aux membres protégés

Pour une classe dérivée, le fait de ne pas pouvoir accéder aux attributs privés peut sembler
embarrassant. Il est alors possible de déclarer les attributs de la classe de base comme
protégés. Dès lors, avec la déclaration suivante dans la classe Point :

Permet d'utiliser de nouveau l'écriture suivante dans la classe Pointcol :

Ce système paraît séduisant puisque la classe de base et ses enfants peuvent accéder aux
attributs protégés sans qu'il soit possible d'y accéder de l'extérieur. Toutefois, il existe un gros
problème, c'est que toutes les classes du même paquetage peuvent également accéder à ces
attributs, et pourtant sans aucun lien de parenté. Il faudra alors avoir beaucoup de réserve
quant à cette approche, puisqu'elle va contre la notion d'encapsulation.

FONKE Eric 6
 COURS JAVA

Une méthode d'une classe dérivée a accès aux membres protégés de sa classe de base.

V .1.5. Construction et initialisation des objets dérivés

Appels des constructeurs

Rappelons que dans le cas d'une classe simple (non dérivée), la création d'un objet
par new entraîne l'appel d'un constructeur ayant la signature voulue (nombre et type des
arguments). Si aucun constructeur ne convient, on obtient une erreur de compilation sauf si la
classe ne dispose d'aucun constructeur et que l'appel de new s'est fait sans argument. On a
affaire alors à un pseudo-constructeur par défaut (qui ne fait rien).

V .1.6. Redéfinition et surdéfinition de membres

a. Redéfinition de membres

C’est le fait de réécrire une méthode se trouvant dans la classe mère dans sa classe fille.

Elle permet à une classe dérivée de redéfinir une méthode de sa classe de base, en en
proposant une nouvelle définition.
Exemple : ces deux méthodes affiche et affichec font un travail semblable

b. Surdéfinition de membres

C’est le fait réécrire une méthode avec des arguments différents.

Exemple :

FONKE Eric 7
 COURS JAVA

V.2. POLYMORPHISME
Le polymorphisme est la faculté attribuée à un objet d’être une instance de plusieurs classes.

Exemple : Point

PointCol

V .2.1. Création de la classe Point

FONKE Eric 8
 COURS JAVA

V .2.2. Création de la classe PointCol

V .2.3. Classe exécutable

FONKE Eric 9
 COURS JAVA

V.3. LES CLASSES ABSTRAITES

C’est une classe qu’on ne peut pas directement instancier car certaines de ses méthodes ne
sont pas implémentées.

V .3.1. Quelques règles

 Dès qu'une classe abstraite comporte une ou plusieurs méthodes abstraites, elle est
abstraite, et ce même si l'on n'indique pas le mot clé abstract devant sa déclaration (ce
qui reste quand même vivement conseillé). Ceci est correct :

Malgré tout, A est considérée comme abstraite et une expression telle que new A(..) sera
rejetée.

 Une méthode abstraite doit obligatoirement être déclarée public, ce qui est logique
puisque sa vocation est d'être redéfinie dans une classe dérivée.
 Dans l'en-tête d'une méthode déclarée abstraite, les noms d'arguments muets doivent
figurer (bien qu'ils ne servent à rien) :

 Une classe dérivée d'une classe abstraite est obligée de (re)définir toutes les méthodes
abstraites de sa classe de base. Dans ce cas, elle reste simplement abstraite (bien que
ce ne soit pas obligatoire
 Une classe dérivée d'une classe non abstraite peut être déclarée abstraite et/ou contenir
des méthodes abstraites.

V .3.2. Intérêt des classes abstraites

Le recours aux classes abstraites facilite largement la Conception Orientée Objet. En effet, on
peut placer dans une classe abstraite toutes les fonctionnalités dont on souhaite disposer pour
toutes ses descendantes :

FONKE Eric 10
 COURS JAVA

 Soit sous forme d’une implémentation complète de méthodes (non abstraites) et de

champs (privés ou non) lorsqu’ils sont communs à toutes ses descendantes,
 Soit sous la forme d’interface de méthodes abstraites dont on est alors sûr qu’elles
existeront dans toute classe dérivée instanciable.

C'est cette certitude de la présence de certaines méthodes qui permet d'exploiter le

polymorphisme, et ce dès la conception de la classe abstraite, alors même qu'aucune
classe dérivée n'a peut-être encore été créée. Notamment, on peut très bien écrire des
canevas recourant à des méthodes abstraites. Par exemple, si vous avez défini :

Vous pourrez écrire une méthode (d'une classe quelconque) telle que :

Bien entendu, la redéfinition de f devra, comme d'habitude, respecter la sémantique prévue

dans le contrat de X.

V .3.3. Exemple : Soit la figure suivante :

FORME

RECTANGLE CARRE CERCLE

FONKE Eric 11
 COURS JAVA

FONKE Eric 12
 COURS JAVA

FONKE Eric 13
 COURS JAVA

Classe exécutable

V.4. LES INTERFACES

Une interface est un type, au même titre qu’une classe, mais abstrait et qui donc ne peut être
instancié (par appel à new plus constructeur). Une interface décrit un ensemble de signatures
de méthodes, sans implémentation, qui doivent être implémentées dans toutes les classes qui
implémentent l’interface. L’utilité du concept d’interface réside dans le regroupement de
plusieurs classes, tel que chacune implémente un ensemble commun de méthodes, sous un
même type. Une interface possède les caractéristiques suivantes :
 elle contient des signatures de méthodes ;
 elle ne peut pas contenir de variables ;
 une interface peut hériter d’une autre interface (avec le mot-clé extends) ;
 une classe (abstraite ou non) peut implémenter plusieurs interfaces. La liste des
interfaces implémentées doit alors figurer après le mot-clé implements placé dans la
déclaration de classe, en séparant chaque interface par une virgule.

FONKE Eric 14
 COURS JAVA

Dans notre exemple, Forme peut être une interface décrivant les méthodes qui doivent être
implémentées par les classes Rectangle et Cercle, ainsi que par la classe Carre (même si celle-ci
peut profiter de son héritage de Rectangle). L’interface Forme s’écrit alors de la manière
suivante :

Pour obliger les classes Rectangle, Cercle et Carre à implémenter les méthodes surface() et
affiche(), il faut modifier l’héritage de ce qui était la classe Forme en une implémentation de
l’interface définie ci-dessus :

NB : Si une classe implémente une interface mais que le programmeur n’a pas écrit
l’implémentation de toutes les méthodes de l’interface, une erreur de compilation se produira
sauf si la classe est une classe abstraite.

Exemple :

FONKE Eric 15
 COURS JAVA

FONKE Eric 16
 COURS JAVA

FONKE Eric 17