Les méthodes abstraites et les interfaces

Bonjour à tous , étant en train d'apprendre , je suis confronté auw interfaces dont je ne vois pas vraiment l'utilité , si quelqu'un a l'habitude de les utiliser , pourrait-il m'expliquer dans quel cas ?
Merci

Les interfaces servent a repondre aux problemes de l'heritage multiple... des fois tu aimerais que ta classe herite de deux classes differents. Pour des raisons techniques, c'est pas autorisé en Java mais pour ne pas perdre en expressivite, il y a les interfaces.

Imagines que tu veuilles modeliser des personnes avec leur fonctions, etc ...

tu peux imaginer creer une classe abstraite Humain. Pour des raisons assez simple, c'est une classe abstraite car tu as soit un homme, soit une femme. On vas donc creer deux classes qui vont herite d'Humain : Homme et Femme.

Maintenant, tu veux faire une autre classification, par exemple les nationalites. Tu voudrais par exemple que les francais puissent manger du fromage, les anglais boire du the, etc ...

Tu vas donc creer des interfaces :

Code:

---

1 2 3 4 5 6 7 8

public interface Francais { public void mangerFromage() ; }   public interface Anglais { public void boireThe() ; }

---

Ensuite, si tu veux avoir des homme francais, il faudra que tu cree une nouvelle classe :

Code:

---

1 2 3 4 5 6

public class HommeFrancais extends Homme implements Francais { public void mangerFromage(){ // code de manger fromage } }

---

idem pour femme francaise, anglaise, etc...

Bref, j'espere t'avoir montrer un peu a quoi pouvait servir les interfaces dans un cas concret.

Ca peut aussi servir dans d'autres cas. imagine que tu developpes un logiciel et que tu doives avoir plusieurs "interfaces" ( je parle des interfaces graphique, texte ... bref, rien a voir avec les interfaces java ) mais tu souhaites que quelque soit l'interface, tu puisses lui demander la meme chose. Il est interessant d'utiliser les interfaces. Ainsi tu pourras librement developper ton logiciel sans te soucier de l'interface graphique.

Salut,


Les interfaces permettent de définir des "comportements" sans pour autant spécifier une implémentation concrète...

Par exemple si on prend l'interface List de l'API des Collections de Java. Tu peux voir que cette interface définit un certain nombre de méthode pour gérer des listes d'éléments, comme add(), get() et remove() pour ajouter, lire et supprimer un élément de la liste.

Toutes classes qui implémente l'interface List devra implémenter ces méthodes (en respectant le comportement attendu).

Ainsi il y a deux principales classes qui implémentent cette interface : ArrayList et LinkedList. La première gère un tableau d'objet qui est redimensionné lorsque cela est neccessaire, alors que la seconde utilise une liste chainée.

L'intérêt de l'interface dans ce cas est d'ignorer l'implémentation exacte. Ainsi si tu utilises l'interface correspondante à la place de la classe qui l'implémente :

Code:

---

1 2 3 4 5 6 7

public List createList() { List list = new ArrayList();   // ajout d'element dans la liste   return list; }

---

Bien que tu crées une ArrayList, tu l'utilises toujours en tant que List. Ainsi ton code n'est pas spécifique à une implémentation particulière, et un jour si tu dois en changer pour une raison quelquonque (par exemple parce que tu ne fais que des ajout en début de liste, ce qui est assez lourd avec une ArrayList), il te suffit simplement de changer son instanciation dans le new.

Si au contraire tu aurais eu un code comme celui-ci :

Code:

---

1 2 3 4 5 6 7

public ArrayList createList() { ArrayList list = new ArrayList();   // ajout d'element dans la liste   return list; }

---

Il aurait fallut que tu changes la signature de la méthode, ce qui aurait impacté toutes les méthodes et classes qui utilisait cette méthode...


L'utilisation des interfaces permet donc d'ignorer l'implémentation exacte des méthodes, afin de pouvoir en changer plus facilement...

Les classes abstraites permettent un peu la même chose, sauf q'elles peuvent définir l'implémentation de certaines méthodes (qui dans certain cas peuvent être les mêmes pour plusieurs implémentations différentes) et permet donc de ne pas réécrire plusieurs fois le même code...

Généralement on utilise alors un héritage en trois couche, avec une Interface implémenté par une classe Abstraite dont hérite les Implémentations.

On n'utilise la classe abstraite que pour en hériter lorsqu'on a besoin d'une nouvelle implémentation.




Enfin, deuxième point : les interfaces permettent d'indiquer qu'un objet comporte tel ou tel spécificité. Par exemple l'interface Comparable implique l'écriture d'une méthode compareTo() qui permet de comparer l'objet avec un autre...


Je ne sais pas si j'ai été très clair...

a++

ok merci j'ai compruis