Interfaces et Polymorphisme

en java
I - Problématique
Nous avons vu que l’héritage implique 2 techniques : la
généralisation et la spécialisation. Il est parfois difficile de mettre en
œuvre la généralisation donc de trouver des attributs communs à
des classes.
Exemple :
Un rectangle, un cercle, un triangle, un cylindre sont des formes
géométriques. Par conséquent, les classes Rectangle, Cercle,
Triangle et Cylindre(sous-classes) héritent de la classe Forme (classe
de base abstraite). Il est difficile de trouver des attributs communs à
ces sous-classes pour les placer dans la classe de base abstraite
Forme. Dans ces cas, il suffit de remplacer la classe de base
abstraite par un nouveau type appelé une interface. En effet
contrairement à une classe, une interface ne possède pas
d’attributs. D’autre part, chacune des sous-classes précédemment
citées possède un périmètre et une surface. On voudrait alors bien
mettre en place des méthodes polymorphiques perimetre() et
surface() (méthodes dont le nom est unique dans le graphe
d’héritage et dont le code varie en fonction du type d’objet dans les
sous-classes) comme ce serait le cas dans une classe abstraite. Il n’y
a pas de problème car une interface aussi convient puisque toutes
les méthodes qui s’y trouvent sont abstraites.
Conclusion : Chaque fois que l’on ne trouve pas d’attributs
communs en généralisant dans l’héritage, on remplace alors la
classe de base abstraite par une interface.
II – Définition d’une interface
Une interface est un type comme une classe. Une interface ne
contient ni attributs, ni constructeur, ni getters et setters. Elle
comporte que des méthodes qui sont toutes abstraites. Comme les
classes abstraites,on ne peut créer des objets d’une interface.
La relation qu’il y a entre une classe et une interface est de type
implémentation( mot clé implements). Une classe ne peut hériter
que d’une seule classe mais peut implémenter plusieurs interfaces.
Lorsqu’une classe concrète implémente une interface, il y a alors un
contrat entre la classe et l’interface qui est l’obligation pour la
classe concrète de rendre concrètes toutes les méthodes abstraites
de l’interface.
Lorsqu’une classe abstraite implémente une interface, elle laisse les
méthodes abstraites de l’interface encore abstraites à son niveau.
L’héritage est une technique qui permet de fédérer des classes
d’objets naturellement liées. L’interface permet de fédérer toutes
les classes d’objets qui l’implémentent naturellement liées ou pas
en leur imposant un comportement (elles doivent implémenter les
méthodes abstraites de l’interface).
Structure d’une interface I quelconque
public interface I
{
//méthodes abstraites
}
Lorsqu’une classe concrète implémente l’interface I, elle a alors la
structure suivante :
public class C implements I
{
//attributs
//constructeur, getters et setters
//implémentation des méthodes abstraites de l’interface I
}
On peut alors créer un objet de type C en utilisant 2 syntaxes
possibles :
- Créer l’objet classiquement via C et le typer par C
C nom_objet = new C(…) ;
- Créer l’objet via C et le typer par I
I nom_obet = new C(…) ;
Dans ce dernier cas de syntaxe, on peut mettre alors en œuvre
le polymorphisme de structures et de méthodes.
III -TP à réaliser

Un rectangle et un cercle sont des formes donc les classes Rectangle et Cercle
héritent de Forme qui est en principe une classe abstraite. Cependant , les
classes Rectangle et Cercle n’ont pas d’attributs communs qui doivent migrer
vers Forme. Par conséquent, Forme est alors une interface dans laquelle on
définira 3 méthodes abstraites polymorphiques : afficher(), perimetre() et
surface().
Les sous-classes concrètes Rectangle et Cercle devront rendre concrètes ces
trois méthodes.
On mettra aussi en place une liste polymorphique ArrayList de type Forme
qui pourra stocker à la fois des objets Cercle et Rectangle.