PROGRAMMATION GRAPHIQUE CHAPÎTRE 1.

CHAPÎTRE 1.2 – LES INTERFACES

En Java, il n’est pas possible de faire hériter une classe de plusieurs classes de base en même
temps (héritage dit multiple). Pour remédier au problème, on utilise les interfaces. Ainsi, Une
classe dérivée ne peut hériter que d'une seule classe de base (peut être abstraite), mais elle
peut implémenter plusieurs interfaces.

1. Caractéristiques :
Une interface se veut comme un patron de conception. Elle offre la possibilité de représenter,
sans les implémenter, un ensemble de comportements.

Une interface est une déclaration de classes qui ne comporte que des méthodes abstraites et
des constantes, c’est à dire, des données final.
Une interface peut comporter une variable, mais c’est rare.

Une classe qui dérive d’une interface doit redéfinir l’ensemble des méthodes afin qu’elle ne
soit pas abstraite elle aussi.

2. Déclaration d’une interface

syntaxe
« protection » interface [NomInterface] {
// Données membres (souvent de type « public final »)
// Méthodes de type « abstract »…
}

La protection « protection » peut-être public ou rien (paquetage). Si public, tous les membres
de l'interface sont "public".
Comme une classe, une interface déclarée public doit être enregistrée dans un fichier portant
le même nom.
Exemple :

public interface Demo {

final int ZERO=0;
int methode1(int n); //public et abstract sont facultatifs
void methode2(int n); //public et abstract sont facultatifs
}
• Les méthodes d’une interface étant par défaut abstraites, le terme « abstract » n’est
pas obligatoire.
• Les constantes d’une interface peuvent être utilisées comme si elles étaient directement
déclarées dans la classe implémentant l’interface.

3. Implémentation d’une interface

Pour faire dériver une classe d’une interface, on se sert du mot clé implements.
Syntaxe :

420-326-MO PAGE 1
PROGRAMMATION GRAPHIQUE CHAPÎTRE 1.2

« protection » class [nomDeLaClasse] implements [NomInterface1],

[NomInterface2]
{
//corps de la classe
}
« protection » peut-être public ou rien (paquetage).

Il ne faut pas oublier qu’une classe qui dérive d’une interface doit redéfinir l’ensemble des
méthodes de cette interface afin qu’elle ne soit pas abstraite elle aussi.
Java ne permet pas de restreindre l’accès d’une méthode héritée.

Exemple :
public interface Fonction {
int appliquer(int n);
}

public class LeDouble implements Fonction{

public int appliquer(int n){
return n + n;
}
}

public class LeCarre implements Fonction{

public int appliquer(int n){
return n * n;
}
}

public class LeCube implements Fonction{

public int appliquer(int n){
return n * n * n;
}
}

public class TestFonction {

public static void main(String arg[]){
Fonction f1 = new LeDouble( );
Fonction f2 = new LeCarre( );
Fonction f3 = new LeCube( );
System.out.println(f1.appliquer(10));
System.out.println(f2.appliquer(10));
System.out.println(f3.appliquer(10));
}
}
Résultat d’exécution :
20
100
1000

Une classe peut dériver d’une classe mère et implémenter une ou plusieurs interfaces, ce qui
peut être considéré comme de la dérivation multiple.

public interface Affichable {

public void dessine();
}
public interface Deplacable {
public void deplace();

420-326-MO PAGE 2
PROGRAMMATION GRAPHIQUE CHAPÎTRE 1.2

}
public class ClasseFille extends ClasseMere implements Affichable ,
Deplacable
{
public void dessine() {
// ici le code pour dessine
}
public void deplace() {
// ici le code pour deplace
}
public void autreFonction() {
// ici le code pour autreFonction
}

Représentation graphique
« Interface » « Interface »
Affichable Deplacable ClasseMere

public void dessine() public void deplace() …

…

ClasseFille

public void dessine()

public void deplace()
public void autreFonction()

4. Héritage sur les interfaces

Comme les classes, les interfaces peuvent hériter les unes des autres. Mais étant donné
son contenu, une interface ne peut implémenter une autre. En réalité, cette opération
permet simplement de concaténer les déclarations

Contrairement aux classes, les interfaces supportent l’héritage multiple.

Exemple d’interfaces avec héritage multiple:

public interface A
{ void Lecture(); }

420-326-MO PAGE 3
PROGRAMMATION GRAPHIQUE CHAPÎTRE 1.2

public interface B
{ void Ecriture(); }

public interface C extends A, B

{ static final int MODELECTURE = 1;
static final int MODELECRITURE = 2;
}

5. Comment différentier le choix entre une classe, une sous-classe, une

classe abstraite ou une interface ?

• On choisit de faire une classe si elle ne dérive d’aucune classe autre que la classe
Object.

• On choisit de faire une sous-classe (dériver une classe) seulement on a besoin d’être
plus spécifique sur une version d’une classe et qu’on a besoin de surcharger ou
d’ajouter de nouvelles méthodes.

• On choisit d’utiliser une classe abstraite quand on veut définir un modèle pour un
groupe de sous-classe, et on a au moins quelques implémentations de code que toutes
les sous-classes peuvent utiliser. On utilise la classe abstraite si on ne veut pas que
personne puissent faire des objets du type de la classe définie.

• On choisit d’utiliser les interfaces quand on veut définir un rôle que les autres classe
peuvent jouer, indifféremment de où ces classes sont dans l’arbre d’héritage.

420-326-MO PAGE 4