271 Les interfaces
Abstraction
272
Des objets implémentant des services identiques de façons
différentes :
Les objets implémentent les méthodes afficher(String s) et alerter()
Abstraction et interface
273
• Une interface peut être vue comme un contrat entre celui qui
utilise les objets et celui qui les implémente.
Les interfaces
274
Une classe définit des méthodes avec leur code (leur
définition)
Une interface définit des méthodes sans leur code
(méthodes abstraites)
Une interface ne peut pas être instanciée
N’a pas de constructeurs
Elle est destinée à être « implémentée » par des
classes (mot clé implements)
Qui fourniront des définitions pour les méthodes déclarées
(code)
Les interfaces
275
Une interface est une déclaration permettant de
décrire un ensemble de méthodes abstraites et des
constantes:
Une interface est une classe abstraite dont toutes les
méthodes le sont
On peut considérer une interface comme étant une
classe abstraite ne contenant que:
des méthodes abstraites
et que des attributs constants (qui doivent obligatoirement
être initialisés.)
interface NOM { …}
Les interfaces
276
Toutes les méthodes sont
public interface I {
void f(int n) ; //equivalent à
implicitement abstraites et
public abstract void f(); publiques
void g() ;
//les méthodes f et g sont des
Possibilité de définir des
méthodes abstraites et publiques attributs à condition qu’il
; il n’est pas nécessaire de les s’agisse d’attributs de type
déclarer avec le mot clé abstract
et le modificateur
primitif
public Ces attributs sont implicitement
int MAXI = 100; //equivalent à
public static final int MAXI =
déclarés comme public static
100 ; //constantes final (Constante)
}
Implémentation ou Réalisation d’une
interface
277
C'est une sorte de standard auquel une classe peut
répondre. On dit une classe implémente une interface:
class Test implements InterfaceA { ….. }
La classe Test définit un sous-type de InterfaceA:
InterfaceA a = null;
a = new Test();
Les méthodes d'une interface doivent être définies par
toutes les classes implémentant l'interface et qui sont
non abstract
Les constantes d'une interface sont accessibles à toutes
les classes implémentant l'interface.
Exemple
278
Exemple
279
Intérêt des interfaces
280
Donner un type commun à des classes différentes pour en faire un
même usage
Exemple:
Manipuler des tableaux de « trucs » qui ont chacun une surface
Faire la somme des surfaces des trucs qui sont dans le tableau
public interface Surfaceable {
public double surface();
}
public class AlgoOnTrucs {
public static double totalSurface(Surfaceable[] array) {
double total = 0.0;
for(Surfaceable truc : array)
total += [Link]();
return total;
}
}
Intérêt des interfaces
281
Les 2 principaux avantages:
L'algo de la méthode totalSurface(Surfaceable[] array) fonctionne
indépendamment de la classe réelle des objets qui sont stockés
dans array: c'est le soustypage
La méthode surface() effectivement appelée sur les objets
contenus dans le tableau sera la plus précise possible, en fonction
du type réel de cet objet: c'est le polymorphisme
public class AlgoOnTrucs {
public static double totalSurface(Surfaceable[] array) {...}
public static void main(String[] args) {
Rectangle rectangle = new Rectangle(2,5);
Square square = new Square(10);
Circle circle = new Circle(1);
Surfaceable[] t = {rectangle, square, circle};
[Link](totalSurface(t)); // 113.1415926535898
}}
Implémentation ou réalisation d’une
282
interface
Plusieurs interfaces peuvent être implémentées dans une
même classe.
public interface I1 {
void f() ;
static final int MAXI = 100 ; }
public interface I2 {
void g() ; }
class A implements I1, I2 {
/*les méthodes f et g des interfaces I1 et I2 doivent
être définies dans la classe A */
/* dans toutes les méthodes de la classe A on a accès à
la constante MAXI */
void g() {….}
void f() {….}
}
Implémentation ou réalisation d’une
283
interface
public interface I1 {
void g() ;
}
public interface I2 {
int g() ; }
class A implements I1, I2 {
int g() {… } //ERREUR: A n’implémente pas void g(),
et les deux méthodes ne peuvent pas coexister dans A
}
Exemple
284
Exemple
285
Références et interfaces
286
public interface Afficheur {..}
Afficheur aff; //OK
Il n'est pas possible d'instancier une interface
Afficheur aff = new Afficheur ; // interdit
Il est possible d'instancier une classe qui implémente
une interface :
class Telephone implements Afficheur {..}
Afficheur aff = new Telephone(); //OK car
Telephone implémente Afficheur
Polymorphisme!
Héritage des interfaces
287
On peut dériver une interface à partir d'une ou plusieurs
autres interfaces.
Une sous interface
hérite de toutes les méthodes abstraites et des constantes de sa
"super-interface"
peut définir de nouvelles constantes et méthodes abstraites
Les définitions de I2 dans les deux cadres sont équivalents:
public interface I1 {
void f() ; public interface I2 {
static final int MAXI = 100 ; void f() ;
} void g() ;
public interface I2 extends I1 { static final int MAXI = 100 ;
void g() ; }
}
Héritage des interfaces
288
Toute classe qui implémente l’interface fille doit
donner une implémentation à toutes les méthodes
mêmes celle héritées
public interface I1 {
void f() ;
static final int MAXI = 100 ;
}
public interface I2 extends I1 {
void g() ;
}
class A implements I2 {
void f() { … }
int g() { … }
}
Classe dérivée et interfaces
289
Une classe dérivée peut implémenter une ou plusieurs
interfaces.
Exemple:
public interface I {
void f(int n) ;
void h() ;
}
class A implements I1, I2 { … }
class B extends A implements I {
//les méthodes f et g de l'interface I sont soit déjà
définies dans la classe A, soit elles doivent l'être
dans la classe B
}
Classe dérivée et interfaces
290
class Rectangle{
double largeur, longueur;
interface Dessinable { double surface() {…}
void dessiner(); double perimetre() {…}
void effacer(); }
}
class RectangleDessinable {
void dessiner() {…}
void effacer() {…}
}
La classe RectangleDessibale hérite de la classe Rectangle et implémente l’interface
Dessinable:
class RectangleDessinable extends Rectangle implements
Dessinable {
public void dessiner() { ………. }
public void effacer() {……..}
}
Classe dérivée et interfaces
291
Dessinable d;
d = new RectangleDessinable (); //cast
implicite de la classe fille vers l’interface
[Link](); //OK, car dessiner() est définie
dans l’interface
[Link](); // ERREUR: (comme pour le cas
d’héritage entre classes, on ne peut pas faire appel
à une méthode qui n’est pas définie dans
l’interface)
Héritage multiple des interfaces
292
En java, l’héritage multiple est interdit.
Pourquoi?
Exemple (the diamond problem):
S’il y a une méthode dans A qui est redefine dans B et C mais
pas dans D, alors quelle version de cette méthode la classe D
utilise-t-elle: celle de B ou celle de C?
Par contre l’héritage multiple des interfaces est possible
Une interface peut dériver d'une autre interface et même
de plusieurs.
Dans ce cas, la première classe à implémenter une interface
devra également implémenter les méthodes des mères de
l'interface.
Exemple
293
Comment peut-on contourner ce problème?
abstract class Robot {
abstract class Animal { …
abstract void talk(); }
}
Interdit, pas
d heritage multiple
class Humanoide{
void talk() {…}
}
class Dog extends class Cat extends
Animal{ Animal{
… …
} }
Exemple
294
Comment peut-on contourner ce problème?
abstract class Robot {
abstract class Animal
…
implements Talkative {
}
abstract void talk();
}
class Humanoide
implements Talkative {
void talk() {…}
}
class Dog extends class Cat extends
Animal{ Animal{
… …
} }
Interface Talkative {
void talk();
}
Exemple dérivation et implémentation
295
public interface InterfaceA {
public void methodA(); }
public interface InterfaceB {
public void methodB(); }
public interface InterfaceAB extends InterfaceA, InterfaceB {
public void otherMethod(); doit definit les méthodes
} methodA, methodB et otherMethod
public class ClassAB implements InterfaceAB{
public void methodA(){ [Link]("A"); }
public void methodB(){ [Link]("B"); }
public void otherMethod(){ [Link]("blablah"); }
public static void main(String[] args) {
ClassAB classAb = new ClassAB();
[Link](); // A
[Link](); // B
[Link](); // blablah
}
}