Vous êtes sur la page 1sur 3

© B. Carré 1 © B.

Carré 2

La notion d'interface abstraite


Que des méthodes
•  A l'extrême des classes abstraites
INTERFACES
abstraites puisqu’on en
•  « pures protocoles » (pas d'implémentation) fournit pas de définition.
•  pas de structure (pas de variables d'instance) Mais pas la peine de

ABSTRAITES
mentionner le mot clé
•  que des méthodes abstraites
abstract.
•  Peuvent être génériques, comme les classes
•  Spécifient des « capacités » transversales aux classes qu'elles
Mise en œuvre en Java implémentent:
•  relation implements (n-aire)
•  en plus de extends (unaire)
•  Exemple
interface Displayable {
void display();
void displayAt(Point p); Utilisation du mot
… clé interface.
}

© B. Carré 3 © B. Carré 4

Application Implémentation d'interface


Implémentation d'interfaces : par les classes

public class Rectangle implements Displayable {


public void display() {//implantation...}
public void displayAt(Point p) {//implantation...}
...} Rectangle doit définir
les méthodes prévues
public class And dans l’interface
extends Porte Displayable.
implements Displayable
// implantation de display et displayAt...

public class Or Une même classe peut


extends Porte implémenter plusieurs
implements Displayable interfaces.
//implantation de display et displayAt...
© B. Carré 5 © B. Carré 6

Exemples du langage et de bibliothèques Interface comme type


•  Comparable<E> (pour java.util) •  Tout comme une classe, une interface définit un type d'objets
•  des objets qui offrent une relation d'ordre (méthode compareTo) •  Typage souple : un objet est du type de l'interface si sa classe
•  Iterable<E>! l’implémente (directement ou par héritage)
•  Des séquences d'objets (tableaux, listes, …) : next()/hasNext() •  Les règles du polymorphisme s'appliquent
•  Cloneable! Bien entendu, on ne peut
•  objets dont on peut obtenir une copie par la méthode clone() // interface abstraite => typage souple pas instancier une interface
Rectangle r; (pas plus qu’on ne pouvait
•  Serializable (pour java.io) instancier une classe
And a;
•  objets que l'on peut sauvegarder/lire sur fichier par : abastraite).
readObject(ObjectInputStream in) Displayable x;
writeObject(ObjectOutputStream out)
//affectation polymorphe
•  Protocoles d'écoutes d'évènements des composants d'interfaces
graphiques (java.awt, javax.swing) x=r;
x=a;
public interface ActionListener extends EventListener{
x=pick();
void actionPerformed(ActionEvent e);}

© B. Carré 7 © B. Carré 8

Interface comme type Interface comme type


•  Comme type d'éléments de tableaux (et de collections) public class Rectangle implements Displayable,
public class Graphic {! Comparable<Rectangle> {!
protected Displayable[] figures;! public double surface() {…}!
public void add(Displayable fig) {…}! public void display() {…}!
public void show() {! public int compareTo(Rectangle r) {!
for (Displayable fig : figures) fig.display();! return (int)(this.surface() - r.surface());!
}! }!
}!
}!
!
public class Pavage {!
•  Comme type de paramètre
protected Rectangle[] rectangles;!
Graphic g;
On peut manipuler des objets de public void sort() {!
!
g.add(r); classes quelconques, non Arrays.sort(rectangles); // <= Comparable!
g.add(a); nécessairement liées par héritage, }!
g.add(x); pour peu qu’elles implémentent }
! Displayable!
!
© B. Carré 9 © B. Carré 10

Interface et classe abstraite Hiérarchie de classes et d'interfaces


•  Une classe •  Une classe est sous-classe d'une seule classe mais peut implémenter
•  doit implémenter tout le protocole de l'interface plusieurs interfaces ( héritage multiple de classes abstraites en C++)
•  sauf si elle est abstraite : public class ArrayList<E>
elle peut alors laisser abstraites certaines méthodes extends AbstractList<E>
! implements List<E>, Cloneable, Serializable
public abstract class Porte implements Displayable {! •  Une interface peut étendre (extends) une ou plusieurs interfaces
!// display() remains abstract! public interface MouseInputListener //AWT
}! extends MouseListener, MouseMotionListener {...}
public class And extends Porte {!
public void display() { //code…}! <extends extends>
}!
public class Or extends Porte {! * *
public void display() { //code…}! 1 implements>
Class Interface *
}! * *

Vous aimerez peut-être aussi