L'utilité des Interfaces

Bonjour, je suis en train de lire un livre pour apprendre JAVA. Mais je ne parviens pas à saisir l'utilité des INTERFACES. En effet, si les méthodes de l'interface ne sont pas implémentées, pourquoi implémenter une INTERFACE dans une classe ? Quelqu'un peut m'expliquer avec un exemple. Merci beaucoup.

Salut !

L'utilité des interfaces c'est justement d'imposer des méthodes aux classes qui vont implémenter cette interface.

Un exemple pour faire un jeu avec des véhicules

une interface "Véhicule" pourra contenir une méthode "seDeplacer()".

Tu l'implémentes dans 2 classes :

Code:

---

1 2 3 4 5 6

public class Voiture implements Vehicule{ public void seDeplacer(){ //Ici sera codé tout ce qui permettra à la voiture de rouler } }

---

Code:

---

1 2 3 4 5 6

public class Avion implements Vehicule{ public void seDeplacer(){ //Ici sera codé tout ce qui permettra à l'avion de voler } }

---

Du coup tu sais que tu pourra appeler seDeplacer() sur tous les véhicules :

Code:

---

1 2 3 4 5 6 7 8

ArrayList<Vehicule> mesVehicules = ... //mesVehicules contient des voitures et des avions //Parcours toute la liste for (Vehicule vehicule : mesVehicules) { //Appelera la méthode de Voiture ou Avion en fonction du type réel du véhicule vehicule.seDeplacer(); }

---

Vu qu'on sait qu'un véhicule peut forcément se déplacer ( c'est un comportement imposé), on peut traiter tous les véhicules de la même façon sur ce point là.

J'espère avoir été assez clair !

Merci legentil . . . Mais ça ne rentre pas. Pourquoi les classes Avion et Voiture n'ont pas leur propre méthode vu que l'un vole et l'autre roule ?

Au final, tu utilises la classe Avion et la classe Voiture non ? Pas l'interface lui-même.

Désolé. Je suis dur à la détente.

Après mure réflexion, mon exemple n'est peut être pas très bien choisi, un héritage s'appliquerai mieux à ce cas il me semble. Ce qu'il faut garder en tête, c'est qu'une interface est là pour imposer un comportement à tes objets de la classe qui implémente l'interface.

Mon exemple précédent pourrait alors devenir

Code:

---

1 2 3 4

public abstract class Vehicule { public abstract void seDeplacer(); }

---

Code:

---

1 2 3 4

public interface Demarrable(){ public void demarrer(); }

---

Code:

---

1 2 3 4

public interface Roulant(){ public void deraper(); }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Voiture extends Vehicule implements Demarrable, Roulant(){ public void demarrer(){ //imposé par l'interface Demarrable }   public void seDeplacer(){ //imposé par la classe mère abstraite }   public void deraper(){ //imposé par l'interface Roulant } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10

public class Avion extends Vehicule implements Demarrable(){ public void demarrer(){ //imposé par l'interface }   public void seDeplacer(){ //imposé par la classe mère abstraite } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class Velo extends Vehicule implements Roulant{   public void seDeplacer(){ //imposé par la classe mère abstraite }   public void deraper(){ //imposé par l'interface Roulant } }

---

L'avantage est le même que dans mon exemple précédent, tu peux aussi faire des trucs du genre :

Code:

---

1 2 3 4 5

public void deplacerVehicule (Vehicule vehicule) { //Tu n'a pas à te soucier ici du type de véhicule que c'est vehicule.deplacer(); }

---

L'avantage est que si un jour tu rajoute un type de véhicule, cette méthode n'aura pas à être mise à jour.

voilà !

:ccool:
Mille mercis. J'ai compris.

Citation:

---

Au final, tu utilises la classe Avion et la classe Voiture non ? Pas l'interface lui-même.

---

Non au contraire, dans mon premier exemple tu utilises l'interface dans :

Code:

---

1 2 3 4 5 6 7 8

ArrayList<Vehicule> mesVehicules = ... //mesVehicules contient des voitures et des avions //Parcours toute la liste for (Vehicule vehicule : mesVehicules) { //Appelera la méthode de Voiture ou Avion en fonction du type réel du véhicule vehicule.seDeplacer(); }

---

Par contre le code qui sera exécuté sera le code de la méthode du type Voiture ou Avion (selon le type réel de l'objet). ça permet de ne pas se soucier du type réel de l'objet. Le fait de savoir que c'est un véhicule suffit pour savoir qu'il peut être déplacé...

Pour avoir un autre exemple, prenons l'interface List.

Elle est implémentée par les bien connues ArrayList (implémentée avec un tableau) et LinkedList (implémentée en liste chaînée.) Elle est également implémentée par plein de classes privées.

"Justement, si je veux une ArrayList pourquoi utiliser une List ?"

Mais tu ne veux pas une ArrayList, tu veux n'importe quelle List.

Vois cette méthode :

Code:

---

1 2 3 4 5 6

public static int somme(ArrayList<Integer> list) { int somme = 0; for(Integer i : list) { somme += i; } }

---

Elle calcule la somme des entiers contenus dans une ArrayList.

Vois celle-ci :

Code:

---

1 2 3 4 5 6

public static int somme(List<Integer> list) { int somme = 0; for(Integer i : list) { somme += i; } }

---

Elle calcule la somme des entiers contenus dans une List, n'importe laquelle, peu importe qui, où, quand elle a été implémentée, partout dans le monde et à travers les âges.

Les interfaces, ça sert à ça.

Une toute dernière précision. Tu es obligé de définir une méthode d'une INTERFACE ? Si tu ne l'utilises pas . . .

Citation:

---

Envoyé par lyvunny

Une toute dernière précision. Tu es obligé de définir une méthode d'une INTERFACE ? Si tu ne l'utilises pas . . .

---

Oui. Quand on veut implémenter une interface, on dit implémenter toutes ses méthodes, c'est pour ça que l'interface garantit qu'on peut utiliser toutes ses implémentations.

Si tu n'as pas besoin de toutes les méthodes, définis une interface qui a moins de méthodes.

:ccool: :ccool: