Chapitre 4 :

Héritage et
polymorphisme
1
 Généralités
❑L’héritage décrit une relation entre une classe générale
(classe de base, classe mère ou classe parent) et une classe
spécialisée (classe fille ou sous-classe).
❑Les classes spécialisées héritent tous les attributs et toutes
les méthodes de la classe générale.
❑Une classe peut avoir plusieurs sous-classes.
❑Une classe ne peut avoir qu'une seule classe mère : il n'y a
pas d'héritage multiple en Java.

2
 Personne
id:int Classe mere
nom :String
prenom : String
getNom(): String
getPrenom(): String
setNom(String): void
getPrenom(String): void

Etudiant Employe
Classe
filiere :String filles poste :String
getFiliere():String getPoste():String
setFiliere(String):void setPoste (String):void 3
 Mise en œuvre de l’héritage
Déclaration d’une classe fille
❑Pour exprimer que la classe ClasseB hérite les attributs et
les méthodes de la classe ClasseA, on écrira :
public class ClasseB extends ClasseA
❑ClasseA est appelée la classe parent (ou mère) et ClasseB la
classe dérivée (ou fille)
class Etudiant extends Personne{...}
❑Un objet de la classes Etudiant:
❖Hérite les attributs et méthodes de la classe Personne:
✓Il doit disposer d’une valeur pour tous les attributs de la
classe Personne
✓Il peut utiliser toutes les méthodes de la classe Personne
❖Dispose des attributs et des méthodes supplémentaires
❖Peut redéfinir certaines méthodes non statiques de la classe
Personne
4
 Mise en œuvre de l’héritage
Accès aux attributs et méthodes hérités
❑Les attributs et méthodes définis avec le modificateur
d'accès public sont accessible par les sous-classes et
toutes les autres classes.
❑Un attribut défini avec le modificateur private est
hérité mais il n’est pas accessible directement par les
sous-classes.
❑Un attribut défini avec le modificateur protected est
accessible directement dans toutes les classes filles
❑En général :
❖Les attributs d'une classe mère sont déclarées
protected, pour les rendre accessibles directement par
les objets de ses sous-classes;
❖Les méthodes sont déclarées public.
5
 Mise en œuvre de l’héritage
❑Exemple
public class Personne{
protected int id;
protected String prenom;
protected String nom;
public String getNom(){...}
...
}

6
 Mise en œuvre de l’héritage
❑Exemple
class Etudiant extends Personne{
private String filiere;
public String getFiliere(){...}
public void setFiliere(String f){...}
...
}
class Employe extends Personne{
private String poste;
public String getPoste(){...}
public void setPoste(String f){...}
...
} 7
 Mise en œuvre de l’héritage
Déclaration du constructeur d’une sous-classe
❑Le constructeur d’une sous-classe doit toujours
commencer par appeler le constructeur de sa classe
mère.
❑L’appel du constructeur de la classe mère se fait avec
l’instruction super(paramètres), avec les paramètres
adéquats.
❑La première instruction d’un constructeur peut être
un appel
❖ à un constructeur de la classe mère : super(...)
❖ ou à un autre constructeur de la classe : this(...)
❑ Interdit de placer this() ou super() ailleurs qu’en
première instruction d’un constructeur
8
 Mise en œuvre de l’héritage
❑Exemple
public class Personne{
protected String prenom;
protected String nom;
...
public personne(String prenom,String nom){
[Link]=prenom;
[Link]=nom;
}
}

9
 Mise en œuvre de l’héritage
❑Exemple
public class Etudiant extends Personne{
private String filiere;
...
public Etudiant(String prenom,String nom, String
filiere){
super(prenom, nom);
[Link]=filiere;
}
}

10
 Mise en œuvre de l’héritage
Constructeur de la classe mère
public class Rectangle {
private int lar, lon;
public Rectangle(int largeur, int hauteur) {
[Link] = largeur;
[Link] = longueur;
}
...
}
 Mise en œuvre de l’héritage
Constructeurs de la classe fille
public class RectangleColore extends Rectangle {
private int coul;
public RectangleColore(int lar, int lon, int cou) {
super(lar, lon);
[Link] = cou;
}
public RectangleColore(int lar, int lon) {
this(lar, lon, 0);
}
...
}
 Redéfinition d'une méthode héritée
(Overriding)
❑On appelle redéfinition le fait de réécrire dans une
classe fille une méthode de la classe mère.
❑La méthode de la classe fille porte le même nom et
possède les mêmes paramètres que la méthode de la
classe mère.
❑Si la signature de la méthode change (les paramètres),
ce n'est plus une redéfinition (Overriding) mais une
surcharge (overloading).

13
 Redéfinition d'une méthode héritée
(Overriding)
❑Exemple : Redéfinition de la méthode toString() de la classe
mère Personne, dans la classe fille Étudiant :
public class Personne{
protected String nom;
protected String prenom;
public Personne(String nom,String prenom){
[Link]=nom;
[Link]=prenom;}
public String toString(){
return "Nom:"+[Link]+",Prenom:"+[Link];}
}
}
14
 Redéfinition d'une méthode héritée
(Overriding)
public class Etudiant extends Personne{
private String filiere;
public Etudiant(String nom, String prenom, String
filiere){ super(nom, prenom);[Link]=filiere; }
public String toString() {
return "Nom:"+[Link]+",Prenom:"+[Link]+ ",
Filiere: "+ [Link];
}
public static void main(String arg[]){
Etudiant e=new Etudiant("Ahmed", "Ali",
"Informatique"); [Link]([Link]());
}
} Resultat affiché:
Nom:Ahmed, Prenom:Ali, Filiere: Informatique 15
 Redéfinition d'une méthode héritée
(Overriding)
Le mot-clé super
❑Le mot-clé super permet de désigner la classe mère.
❑À l'aide du mot-clé super, il est possible de manipuler
les attributs et les méthodes de la classe mère.
❑Pour manipuler un attribut de la classe mère, il suffit
d'utiliser la syntaxe suivante :
[Link]
❑De la même façon, pour manipuler une méthode de la
superclasse, il suffit d'utiliser la syntaxe suivante :
[Link]()

16
 Redéfinition d'une méthode héritée
(Overriding)
❑Exemple: Appel de la méthode toString() de la classe
mère Personne, dans celle de la classe fille Etudiant :
public class Personne{
...
public String toString(){
return "Nom:"+[Link]+",Prenom:"+[Link];
}
}

17
 Redéfinition d'une méthode héritée
(Overriding)
❑public class Etudiant extends Personne{
...
//Redefinition de la méthode toString()
public String toString() {
return [Link]()+", Filiere: "+ [Link];
}
public static void main(String arg[]){
Etudiant e=new Etudiant("Ahmed", "Ali",
"Informatique");
[Link]([Link]());}
} Resultat affiché :
} Nom : Ahmed, Prenom:Ali, Filiere: Informatique
18
 L’abstraction
❑L'abstraction consiste à cacher les détails complexes
d'une fonction ou d'une classe pour ne montrer que
l'essentiel.
❑Elle permet de créer des structures de données
génériques et des méthodes sans se soucier de la
manière dont elles seront implémentées concrètement.
❑Les utilisateurs de ces classes ou méthodes n'ont
besoin de connaître que ce qui est nécessaire pour les
utiliser.
❑L'objectif est de créer une structure que les sous-
classes vont étendre et pour laquelle elles vont fournir
les détails spécifiques.
19
 L’abstraction
❑Objectifs de l'abstraction :
❑Simplifier la complexité : En masquant les détails
d'implémentation, l'abstraction rend le code plus facile
à comprendre et à maintenir.
❑Réutilisation du code : En fournissant une interface
générale (par exemple, des méthodes abstraites), les
classes concrètes peuvent hériter et spécialiser ces
comportements.
❑Séparation des responsabilités : Les détails
d'implémentation sont séparés des interfaces ou des
concepts abstraits, ce qui permet de changer
l'implémentation sans affecter les autres parties du
programme.
20
 L’abstraction
❑L’abstraction s’applique aux méthodes et aux classe
❑Une méthode abstraite est une méthode déclarée avec
le modificateur abstract et sans corps :
abstract typeDeRetour nomMethode (params)
❑Une méthode déclarée abstract ne peut être exécutée.
Sa déclaration indique simplement que les sous-classes
doivent la redéfinir.
❑Toute classe qui possède au moins une méthode
abstraite doit être déclarée abstraite :
abstract class NomDeClasse { ... }

21
 L’abstraction
❑Une classe abstract ne peut pas être instanciée (On ne
peut pas créer des objets d’une classe abstraite).
❑Une classe abstraite peut avoir des sous-classes qui
implémentent les méthodes abstraites.
❑Si une sous-classe ne redéfinie pas de façon concrète
une méthode abstraite, la sous-classe doit être déclarée
explicitement absraite.

22
 L’abstraction
Problème
Dans la classe mère Forme :
❑Il n’est pas possible d’écrire une méthode getSurface()
: Chaque sous-classe a sa propre méthode getSurface().
❑On a besoin de la méthode getSurface() dans la classe
Forme pour écrire la méthode plusEtendueQue(Forme
f) qui détermine si une autre forme possède une surface
supérieure ou inférieure à celle de l’objet appelant.

23
 «abstract»
Forme
id:String
couleur:String
getId():String
setId(String id):void
getCouleur():String
setCouleur:(String c):void
plusEtendueQue(Forme f):boolean
getSurface():double
Rectangle
longueur:float
largeur:float
Cercle
getLongeur():double
getLargeur():double rayon:float
setLongeur(double:ln):void getRayon():double
setLargeur(double:lr):void setRayon(float r):double 24
 L’abstraction
Solution
Définir au niveau de la classe générique Forme la
méthode abstraite getSurface(); dont on ne précise pas le
comportement, mais qui sera appelée dans la méthode
plusEtendueQue(Forme f).
Toutes les classes qui héritent de cette classe (Rectangle,
Cercle,…) devront spécifier concrètement la méthode
getSurface().

25
 «abstract»
Forme
id:String
couleur:String
getId():String
setId(String id):void
getCouleur():String
setCouleur:(String c):void
plusEtendueQue(Forme f):boolean
Rectangle abstract getSurface():double
longueur:float
largeur:float
Cercle
getLongeur():double
getLargeur():double rayon:float
setLongeur(double:ln):void getRayon():double
setLargeur(double:lr):void setRayon(float r):double
getSurface():double getSurface():double 26
 L’abstraction
abstract class Forme {
protected String id;
protected String couleur;
public Forme(String id, String couleur) {
[Link] = id; [Link] = couleur;
}
public String getId() { return id; }
public void setId(String id) { [Link] = id;}
public String getCouleur() { return couleur; }
public void setCouleur(String couleur) { [Link] =
couleur;}
// Méthode abstraite pour obtenir la surface
public abstract double getSurface();
public boolean plusEtendueQue(Forme f) {
return [Link]() > [Link]();
}
}
27
 L’abstraction
class Rectangle extends Forme {
private double longueur;
private double largeur;
public Rectangle(String id, String couleur, double longueur,
double largeur) {
super(id, couleur);
[Link] = longueur;
[Link] = largeur;
}
public double getLongueur() {
return longueur;
}
public void setLongueur(double longueur) {
[Link] = longueur;
} 28
 L’abstraction
public double getLargeur() {
return largeur;
}
public void setLargeur(double largeur) {
[Link] = largeur;
}
// Implémentation de la méthode abstraite getSurface
@Override
public double getSurface() {
return longueur * largeur;
}
}
29
 L’abstraction
class Cercle extends Forme {
private double rayon;
public Cercle(String id, String couleur, double rayon) {
super(id, couleur); [Link] = rayon;
}
public double getRayon() { return rayon; }
public void setRayon(double rayon) { [Link] = rayon; }
// Implémentation de la méthode abstraite getSurface
@Override
public double getSurface() {
return [Link] * rayon * rayon;
}
}
30
 L’abstraction
public class Main {
public static void main(String[] args) {Rectangle rectangle = new
Rectangle("R1", "Rouge", 5.0, 3.0);
[Link]("Rectangle ID: " + [Link]());
[Link]("Couleur: " + [Link]());
[Link]("Surface du rectangle: " +
[Link]());
Cercle cercle = new Cercle("C1", "Bleu", 2.5);
[Link]("Cercle ID: " + [Link]());
[Link]("Couleur: " + [Link]());
[Link]("Surface du cercle: " + [Link]());
if ([Link](cercle)) {
[Link]("Le rectangle a une surface plus grande que
le cercle.");
}
else {
[Link]("Le cercle a une surface plus grande que le
rectangle.");
}
31
 Le polymorphisme
❑Le polymorphisme est la capacité, pour un même
message de correspondre à plusieurs formes de
traitements selon l'objet auquel ce message est adressé.
❑En JAVA, le moyen de réaliser le polymorphisme est le
transtypage (cast en anglais).
❑Le cast s’applique sur les types de base, et sur les
classes.

32
 Le polymorphisme
Cast des types de base
❑C’est la conversion de types qui se fait entre les types de
base du langage java, (byte, short, int, long, float, double,
char).
❑Le cast peut être implicite ou explicite :
❑Un transtypage est implicite si le type cible a un domaine
de valeurs plus grand que le type d'origine : byte (1 octets)
–> short (2-> int -> long -> float (4)-> double (8).
❑Exemple de transtypage implicite
int i =3;
double d = i; //d vaut 3.0
❑Un transtypage est explicite si le type cible a un domaine
de valeurs plus petit que le type d'origine.
❑Exemple de transtypage explécite
double d = 3.96;
int i = (int)d; //i vaut 3
33
 Le polymorphisme
Cast entre classes
❑Il est possible de convertir un objet d'une classe
A en un objet d'une classe B si les classes A et B
ont un lien d'héritage.
❑Le transtypage d'un objet dans le sens fille ->
mère est toujour possible et implicite.
❑Le transtypage dans le sens mère -> fille doit
être explicite et n'est pas toujours possible.

34
 Le polymorphisme
Le cast implicite (sens fille -> mère )
❑Il est possible d'utiliser une référence de la
classe mère pour désigner un objet d’une classe
dérivée (fille, petite-fille et toute la descendance).
❑Le cast de la classe fille vers la classe mère est
implicite
❑Un objet a:
❖Un type déclaré dans le code source (vérifié à
la compilation par Javac)
❖Un vrai type : celui qui lui est donné lors de
l'appel du constructeur (vérifié à l’exécution
par la JVM).

35
 Le polymorphisme
❑Exemples
public class Personne{
private String nom;
...
private void setNom(String n){[Link]=n;}
...
}
public class Etudiant extends Personne{
private String filiere;
...
private void setFiliere(String f){[Link]=f;}
}
36
 Le polymorphisme
❑Exemples
Personne pers = new Etudiant();

Type déclaré Vrai type

Code Correcte/Erreur
Etudiant e1 = new Etudiant(); Correcte
Correcte : Etudiant
Personne p1 = new Etudiant ();
hérite de Personne
Erreur de compilation :
Etudiant n’est pas une
Etudiant e = new Personne();
classe dérivé de
Personne 37
 Le polymorphisme
Code Correcte/Erreur
Personne p2 = e1; Correcte : Etudiant hérite de
Personne
Correcte: Etudiant est une
classe dérivée de Object comme
Object obj=e;
toutes les classes déclarées en
java
Erreur de compilation :
e1= p1; Personne n’est pas une classe
dérivée de Personne

38
 Le polymorphisme

Code Correcte/Erreur
[Link]("Ahmed"); Correcte: setNom() est une
méthode du type déclaré de p1
(Personne)
Erreur de compilation::
setFiliere() n’est pas une
[Link]("Math");
méthode du type déclaré de p1
(Personne)

39
 Le polymorphisme
Le cast implicite (sens fille -> mère )
Il est aussi possible de caster implicitement des
paramètres et des types de retour.
Exemple
Public class Personne{
private String nom;
private String prenom;
private int age;
public boolean plusAgeQue(Personne p){
return [Link]>[Link];
}
...
}
40
 Le polymorphisme
Public class Etudiant extends Personne{
private String filiere;
...
}
public class Test{
public static void main(String arg[]){
Personne p=new Personne("Idir","Kamel",20);
Etudiant e= new
Etudiant("Mohammed","Ali",22,"Informatique");
boolean b=[Link](e);//cast implécite
}

41
 Le polymorphisme
Le cast explicite (sens mère -> fille)
❑Pour utiliser une référence de la superclasse pour
désigner un objet d'une classe dérivée, il faut utiliser un
transtypage explicite.
❑Pour que la transtypage réussisse, le vrai type de
l'objet à convertir doit être la sousclasse.
Code Correcte/Erreur
Etudiant e = new Erreur de compilation : L’objet e
Personne(); est instance de la superclasse
(Personne)

42
 Le polymorphisme

Code Correcte/Erreur
Personne p=new Etudiant; Correct : L’objet p est
Etudiant e = (Etudiant) p; instance de la sous-classe
(Etudiant),
Personne p=new Etudiant; Erreur de compilation :
[Link]("Informatique setFiliere() n’est pas une
") méthode du type déclaré de
p (Personne).
Personne p=new Etudiant; Correcte : Cast explécité
((Etudiant)p).setFiliere("M sens mere -> fille, et le vrai
ath"); type de p est Etudiant.
43
 Le polymorphisme
L’operateur instanceof
❑Pour L’operateur instanceof est utilisé pour tester si un
objet est une instance d’un type donné ou de l’une des sous-
classe de ce type.
❑Example
public class Personne{}
public class Etudiant extends Personne{}
public class Employe extends Personne{}
public class Test {
public static void main (String arg[]){
Personne e = new Etudiant() ;
[Link](e instanceof Etudiant); //true
[Link](e instanceof Personne); //true
[Link](e instanceof Employe); //false
}} 44
 Le polymorphisme
Utilité du polymorphisme
❑Le polymorphisme est très utile pour la création
d’ensembles (tableaux ou listes) regroupant des objets
de classes différentes :
❑Exemple 1
public class Forme {}
public class Rectangle extends Forme {
private double longueur;
private double largeur;
public Rectangle(double longueur, double largeur){
[Link]=longueur;
[Link]=largeur;}
public double getSurface() { return longueur*largeur;}
} 45
 Le polymorphisme
public class Cercle extends Forme{
private double rayon;
public Cercle(double rayon) {
[Link]=rayon;
}
public double getSurface() {
return [Link](rayon,2)*[Link];
}
}

46
 Le polymorphisme
public class TestForme {
public static void main(String[] args){
Forme[] formes=new Forme[4];
formes[0]=new Rectangle(5,10); // Cast implicite
formes[1]=new Cercle(5);//Cast implicite
formes[2]=new Rectangle(10,20);//Cast implicite
formes[3]=new Cercle(10);//Cast implicite
[Link]("Listes des formes et leurs surfaces");
for (int i=0;i<[Link];i++) {
if (formes[i] instanceof Rectangle)
[Link]("Un rectangle de surface:"+
((Rectangle)formes[i]).getSurface());//Cast explicite
if (formes[i] instanceof Cercle)
[Link]("Un Cercle de surface:"+
((Cercle)formes[i]).getSurface());//Castexplicite
}}}
47
 Le polymorphisme
❑Exemple 2
public abstract class Forme {
abstract double getSurface();
}
public class Rectangle extends Forme {
private double longueur;
private double largeur;
public Rectangle(double longueur, double largeur){
[Link]=longueur;
[Link]=largeur;}
public double getSurface() { return longueur*largeur;}
}
48
 Le polymorphisme
public class Cercle extends Forme{
private double rayon;
public Cercle(double rayon) {
[Link]=rayon;
}
public double getSurface() {
return [Link](rayon,2)*[Link];
}
}

49
 Le polymorphisme
public class TestForme {
public static void main(String[] args){
Forme[] formes=new Forme[4];
formes[0]=new Rectangle(5,10); // Cast implicite
formes[1]=new Cercle(5);//Cast implicite
formes[2]=new Rectangle(10,20);//Cast implicite
formes[3]=new Cercle(10);//Cast implicite
for (int i=0;i<[Link];i++) {
[Link](formes[i].getSurface);
}
for (Forme f:formes)
[Link]([Link]());
}
}
50
 Example
❑Créer une classe Personne comprenant :
❖Les données membres : nom (string), prenom (string)
❖Un constructeur initialisant les données membres
❖Une fonction affiche qui affiche les informations sur un
personne.
❑Créer une classe Eleve dérivant de la classe Personne et
comprenant :
❖Les données membres : CNE(int), note(float).
❖Un constructeur initialisant les données membres
❖Une fonction affiche qui affiche les informations sur
l’élève et qui appelle la fonction affiche de la classe
Personne.
❑Écrire une petite application Java d’utilisation.
51
 Example
public class Personne {
// Données membres
protected String nom;
protected String prenom;
// Constructeur pour initialiser les données membres
public Personne(String nom, String prenom) {
[Link] = nom;
[Link] = prenom;
}
// Fonction qui affiche les informations sur une personne
public void affiche() {
[Link]("Nom: " + nom + ", Prénom: " +
prenom);
}
} 52
 Example
public class Eleve extends Personne {
private int CNE;
private float note;
public Eleve(String nom, String prenom, int CNE, float
note) {
// Appel du constructeur de la classe Personne
super(nom, prenom);
[Link] = CNE;
[Link] = note;
}
@Override
public void affiche() {
// Appel de la méthode affiche de la classe de base
[Link](); [Link]("CNE: " + CNE + ",
Note: " + note);
}
} 53
 Example
public class Main {
public static void main(String[] args) {
// Création d'un tableau de Personne
Personne[] personnes = new Personne[3];
// Ajout d'objets Personne et Eleve dans le tableau
personnes[0] = new Personne("Dupont", "Jean");
personnes[1] = new Eleve("Martin", "Julie", 123456,
17.0f);
personnes[2] = new Eleve("Durand", "Paul", 654321,
15.5f);
// Boucle pour afficher les informations des personnes
for (Personne p : personnes) {
//Polymorphisme: appel de la bonne méthode affiche()
[Link]();
}
}
} 54
 Le mot clé final
❑Le mot-clé final s’applique aux variables, méthodes et
classes.
❑Le mot clé final permet d’indiquer qu’un élément ne sera
pas modifié.
Les variables final
❑Une variable déclarée final ne peut plus voir sa valeur
modifiée (une constante).
❑S’il s’agit d’un attribut, les constantes sont aussi
déclarées statiques, pour gagner de la place en mémoire
(une seul copie pour tous les objets).

55
 Le mot clé final
❑Exemple
public class Cercle extends Forme{
static final double PI=3.141592653589793;
private double rayon;
public Cercle(double r) {
rayon=r;
}
public double getSurface() {
return rayon*rayon*PI;
}
}

56
 Le mot clé final
Les méthodes final
❑Dans le cas d’une méthode, cela signifie que les classes
qui héritent de la classe dans laquelle cette méthode est
définie ne peuvent pas redéfinir cette méthode. Les sous-
classes doivent utiliser cette méthode telle quelle.
❑Exemple
public class A{
public final void methode (){…}
...
}
public class B extends A{…
public void methode (){…} //Erreur
...
}
57
 Le mot clé final
Les classes final
❑Dans le cas d’une classe, final signifie qu’aucune autre
classe ne peut hériter de cette classe.
❑Exemple :
public final class A{…}
public class B extends A{…} //erreur
❑Beaucoup de classes de la librairie java sont final, entre
autres : [Link] , [Link] , et
[Link].

58
 Les interfaces
❑Avec l'héritage multiple, une classe peut hériter de
plusieurs super-classes. L’héritage multiple n'existe pas en
Java.
❑Les interfaces permettent de de remplacer l’héritage
multiple
❑Java définit des interfaces et permet à une classe
d'implémenter plusieurs interfaces.
❑Une interface est une collection de méthodes abstraites,
de constantes, de méthodes statiques, et des méthodes par
défaut,
❑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.
59
 Les interfaces
❑Une interface possède les caractéristiques suivantes :
❖elle contient des signatures de méthodes ;
❖elle ne peut pas contenir de variable (attributs) ;
❖une interface peut hériter d’une autre interface ou
plusieurs interfaces (avec le motclé extends) ;
❑Une classe concrète peut implémenter plusieurs
interfaces.
❑Une classe concrète qui implémente une interface doit
nécessairement fournir directement ou indirectement
(dans une de ses super-classes) une implémentation pour
toutes les méthodes abstraites de cette interface.
❑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. 60
 Les interfaces
❑Déclaration d'une interface :
[public] interface nomInterface [extends Interface1,
Interface2 ... ] {
// corps de l’interface
}
❑Une classe implémente une interface, héritant les
méthodes et les constantes de l'interface.
❑Une classe peut implémenter plusieurs interfaces;
❑Implémentation d’une interface
[Modificateurs] class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface 2, ...] {
//corps de la classe
}
61
 Les interfaces
❑Exemple 1
public interface Individu{
String getNom();
String getPrenom();
}
interface AfficheType {
void afficherType();
}
public class voiture implements AfficheType{
...
public void afficherType(){
[Link]("Je suis une voiture");
}
} 62
 Les interfaces
public class Etudiant implements AfficheType, Individu {
...
public String getNom(){
return [Link];
}
public String getPrenom(){
return [Link];
}
public void afficherType(){
[Link]("Je suis un Etudiant");
}
}
63
 Les interfaces
On souhaite disposer de classes permettant de manipuler
des figures géométriques. On souhaite pouvoir caractériser
celles qui possèdent certaines fonctionnalités en leur
demandant d’implémenter des interfaces, à savoir :
❖Affichable pour celles qui disposeront d’une méthode
void affiche (),
❖Tranformable pour celles qui disposeront des deux
méthodes suivantes : void homothetie (double coeff)
❑Écrire les deux interfaces Affichable et Transformable.
❑Ajouter une classe Point qui implémente l’interface
Affichable
❑Ajouter une classe Rectangle qui implémente les deux
interfaces Affichable et Transformable.
❑Ajouter une classe de test.
64
 Les interfaces
On souhaite disposer de classes permettant de manipuler
des figures géométriques. On souhaite pouvoir caractériser
celles qui possèdent certaines fonctionnalités en leur
demandant d’implémenter des interfaces, à savoir :
❖Affichable pour celles qui disposeront d’une méthode
void affiche (),
❖Tranformable pour celles qui disposeront des deux
méthodes suivantes : void homothetie (double coeff) et
void translation (double coeff)
❑Écrire les deux interfaces Affichable et Transformable.
❑Ajouter une classe Point qui implémente l’interface
Affichable
❑Ajouter une classe Rectangle qui implémente les deux
interfaces Affichable et Transformable.
❑Ajouter une classe de test.
65
 Les interfaces

public interface Affichable {

66
 Les interfaces
public class Point implements Affichable {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
@Override
public void affiche() {
[Link]("Point(" + x + ", " + y + ")");
}
}
67
 Les interfaces
punlic class Rectangle implements Affichable, Transformable {
private double largeur; private double hauteur;
public Rectangle(double largeur, double hauteur) {
[Link] = largeur; [Link] = hauteur;
}
@Override
public void affiche() {
[Link](" Largeur: " + largeur + ", Hauteur: " + hauteur);
}
@Override
public void homothetie(double coeff) {
largeur *= coeff; hauteur *= coeff;
}
@Override
public void translation(double coeff) {
largeur += coeff; hauteur += coeff;
}
}
68
 Les interfaces
public class TestFigures {
public static void main(String[] args) {
Point point1 = new Point(3, 4);
[Link]();
Rectangle rectangle1 = new Rectangle(5, 10);
[Link]();
[Link](2);
[Link](6);
}
}

69
 Evolution des interfaces dans Java
❑Java 7
❖Méthodes abstraites (signature)
❖Constantes
❑Java 8
❖Méthodes abstraites (signature)
❖Constantes
❖Méthodes statiques et par défaut
❑Java 9
❖Méthode abstraite (signature)
❖Constantes
❖Méthodes statiques et par défaut
❖Méthodes privées
❖Méthodes statiques privées 70
Définition de constantes dans les interfaces
public interface Constantes {
public static final double G = 9.81;
}
[Link]
public class ChampGravitationnel implements Constantes {
private double vitesse;
public double calculeVitesse(double temps) {
return G * temps;
}
}

71
 Méthode par défaut
❑Une méthode par défaut permet d'écrire une méthode
dans une interface, en fixant sa signature et en donnant
une implémentation.
❑Si une interface possède des méthodes par défaut, toute
classe concrète qui l'implémente est libre de fournir sa
propre implémentation de cette méthode par défaut, ou
d’hériter celle de l’interface.
❑A partir de java 8 : Héritage multiple d’implémentation
avec les méthodes par défaut

72
 Méthode par défaut
❑Example
public interface Vehicule {
void demarrer();
default void klaxonner() { [Link]("Bip bip!");}
}
public class Voiture implements Vehicule {
@Override
public void demarrer() {
[Link]("La voiture démarre.");
}
}
public class Main {
public static void main(String[] args) {
Voiture voiture = new Voiture();
[Link](); [Link]();
}
}
73
 Méthode par défaut
Ambiguïté avec l’héritage multiple
❑Lorsque plusieurs interfaces avec des méthodes par défaut
sont implémentées dans une même classe, il peut y avoir un
conflit si ces interfaces définissent des méthodes par défaut
ayant le même nom et les mêmes paramètres.
❑Exemple :
public interface A {
default void afficher() { [Link]("Interface A");}
}
public interface B {
default void afficher() { [Link]("Interface B"); }
}
public class C implements A, B {
// Provoque une ambiguïté, car afficher() est présent dans les
deux interfaces
} 74
 Méthode par défaut
❑Solution : Résoudre l'ambiguïtéDans de tels cas, la classe
doit redéfinir la méthode pour indiquer explicitement
quelle version elle souhaite utiliser :
public class C implements A, B {
@Override
public void afficher() {
// Appel explicite à l'implémentation de A
[Link]();
}
}

75
 Méthode par défaut
Conflit avec les méthodes de classes
❑Si une classe parent possède une méthode, et qu'une interface
implémentée par cette classe a une méthode par défaut avec la
même signature, la méthode de la classe prend toujours la
priorité.
❑Exemple :
public class Parent {
public void afficher() { [Link]("Classe Parent");}
}
public interface InterfaceA {
default void afficher() { [Link]("Interface A");}
}
public class Enfant extends Parent implements InterfaceA {
// La méthode de Parent sera utilisée, pas celle de InterfaceA
}
76
 Méthode par défaut
Complexité accrue
❑L'ajout de méthodes par défaut dans les interfaces peut
augmenter la complexité du code. Une interface classique était
un simple contrat qui ne pouvait contenir que des méthodes
abstraites.
public interface X {
default void action() { [Link]("Action de X");}
}
public interface Y extends X {
default void action() { [Link]("Action de Y"); }
}
public class Z implements Y {
// La méthode par défaut action() de Y sera exécutée, car elle
est plus proche dans la hiérarchie
} 77
 Méthode d’interface statique
❑En plus de pouvoir déclarer des méthodes default
dans des interfaces, Java 8 nous permet de définir et
d’implémenter des méthodes static dans des interfaces.
❑Comme les méthodes static n’appartiennent pas à un
objet particulier, elles doivent être appelées à l’aide du
nom d’interface précédant le nom de méthode.
❑Définir une méthode static au sein d’une interface est
identique à en définir une dans une classe.

78
 Méthode d’interface statique
// Interface avec une méthode statique
public interface UtilitaireMath {
static int addition(int a, int b) { return a + b; }
static int carre(int a) { return a * a; }
}
public class Main {
public static void main(String[] args) {
int resultatAddition = [Link](5, 3);
int resultatCarre = [Link](4);
[Link]("Addition (5 + 3): " +
resultatAddition);
[Link]("Carré (4): " + resultatCarre);
}
}
79
Méthode privée et méthode statique privée
❑Le Java SE 9 a apporté une petite évolution sur la mise en
œuvre d'interface : il est maintenant possible d'y définir :
❖Des méthodes privées concrètes.
❖Des méthodes statiques privées concrètes.
❑Une méthode par défaut peut invoquer les méthodes
privées et les méthodes statiques privées implémentées
dans la même interface que celle de la méthode par défaut.
❑Une méthode statique d’une interface peut invoquer
seulement les méthodes privées statique du même
interface.
❑Les méthodes privées dans les interfaces sont
particulièrement utiles pour éviter la duplication de code
dans les méthodes par défaut ou dans les méthodes
statiques publiques de l'interface. Ces méthodes privées ne
peuvent être appelées que par d'autres méthodes de
l'interface (qu'elles soient par défaut ou statiques), mais
elles ne sont pas accessibles depuis une classe
implémentant l'interface.
80
Méthode privée et méthode statique privée
public interface Vehicule {
// Méthode par défaut
default void demarrer() {
verifierBatterie();
[Link]("Le véhicule démarre.");
}
// Méthode par défaut
default void arreter() {
verifierBatterie();
[Link]("Le véhicule s'arrête.");
}
// Méthode privée
private void verifierBatterie() {
[Link]("Vérification de la batterie...");
}
}
81
Méthode privée et méthode statique privée
public class Voiture implements Vehicule {
// Pas besoin d'implémenter quoi que ce soit ici
// Les méthodes par défaut sont héritées
}
public class Main {
public static void main(String[] args) {
Voiture voiture = new Voiture();
[Link]();
[Link]();
}
}

82
 Interfaces : Conflits des noms
interface I1 {
void f(int n);
void g();
}
interface I2 {
void f(float x);
void g();
}
class A implements I1, I2 {
// A doit définir deux méthodes f : void f(int) et void f(float),
// mais une seule méthode g : void g()
}
 Interfaces : Conflits des noms
interface I1 {
void f(int n);
void g();
}
interface I2 {
void f(float x);
int g();
}
class A implements I1, I2 {
//pour satisfaire à I1 et I2, A devrait contenir à la fois une
méthode
//void g() et une méthode int g(), ce qui n'est pas possible
//d'après les règles de redéfinition
}
❑ Cette fois, une classe ne peut implémenter à la fois I1 et I2.
 Synthèse
❑Interface : Un ensemble d’exigences pour les classes.
❑Toutes les méthodes d’une interface sont
automatiquement publiques. (pas nécessaire de
fournir le mot clé public)
❑Avant Java 8, les méthodes n’étaient jamais
implémentées dans les interfaces.
❑Les méthodes par défaut (à partir de Java SE 8) sont
héritées comme les méthodes ordinaires et
implémentées dedans les interfaces.
❑Les méthodes privées (à partir de Java SE 9) peuvent
être invoquées seulement dedans les méthodes par
défaut de l'interface où elles appartiennent.

85