Voilà ce n'est pas aussi compliquer :

une classe abstraite est une classe dont les méthode sont abstrait c.à.d lorsque tu déclare une méthode abstract automatiquement tu doit définir la classe " abstract" et elle est utiliser généralement quand d'autre classes vont hériter de cette classe et ils ont la même méthode que la classe mére donc ont l'écrit pour ne pas répeter les mêmes méthodes chaque fois dans ces classes.

pour les interfaces sont utilisés quand d'autres classes qui vont avoir les même méthodes ont les définies dans une interfaces et puis l'implémenter ultérieurement même si tu n'a pas besoin d'une méthode dans l'interface tu doit l'implémenter par exemple tu peut simplement écrire le nom de la méthode puis ouvrir et fermer l'accolade(je crois que s'écrit comme ça non accolade) comme ça : public void méthode(){}. Engénéral il n'y a pas une grande différence entre interface et classe abstraire ; une interface est un cas paticulier d'une classe abstarite .

bonne travail

Bonsoir,
Pour compléter ce que dit Walkhess, l'utilisation d'interfaces et de classes abstraites, ça a deux avantages.
- la factorisation de code. Selon certains, la factorisation est l'un des avantages de la programmation orientée objet, selon d'autres (et j'adhère à ce mouvement de pensée), la factorisation ça ne sert à rien, sauf parfois à concevoir de mauvais programme par souci de "sur-factorisation".
La factorisation, ça consiste à écrire des méthodes dans les classes, de manière à pouvoir les réutiliser sans les retaper dans les classes filles. C'est ce qui est utilisé lorsque tu implémentes des méthodes dans ta classe abstraite : si toutes les classes filles ont le même comportement pour cette méthode, alors elle doit être implémentée une et une seule fois dans la classe abstraite
- l'abstraction (le polymorphisme). C'est la manière d'utiliser une référence vers une interface (qui définit une série de méthodes), et d'utiliser une implémentation concrète, mais sans la connaître.
Par exemple, quand tu vas utiliser une liste (interface java.util.List), tu ne vas pas connaître quelle implémentation tu vas utiliser. Tu vas par contre savoir que tu peux insérer un élément à un endroit, en supprimer un, connaître la taille...
Et donc dans ton code, tu vas utiliser une référence vers une List.
Ensuite, tu vas utiliser réellement une implémentation de cette interface, mais d'un point de vue utilisation, tu ne sauras pas ce que c'est. Que ce soit une LinkedList (suppression et insertion en O(n) par exemple), ou une ArrayList(en temps constant pour ces méthodes), ça ne t'intéresse que lorsque tu compares les performances lors de l'implémentation initiale de ton ensemble. Une fois que c'est fait, tu fais abstraction de cet aspect "bas-niveau" pour te concentrer uniquement sur l'utilisation de ta liste, et donc tu passes par ton interface.

En espérant avoir été un peu plus loin, sans avoir été trop confus...

Cordialement rtfm and jfgi

Merci à vous les deux c'est plus clair maintenant

Bonjour messieur,
je sais que pour certain la "factorisation" semble inutile, mais ici, je vais vous expliquer ce à quoi ça sert. Il y a avant tout une grande nuance entre l'interface et la classe abstraite. L'interface permet de s'assurer que certaine classes filles auront sans aucun doute les méthodes définit dans celle-ci. La classes abstraite elle est un hybride entre une classe conventionnel et un interface. Elle offre une implémentation générique aux classes filles et également leur demande d'implémenter certaines choses pour lesquels la classe abstraite ne peut pas décider. Voici un exemple : Je veux réinventer Java2D et dessiner des formes a ma manière de A à Z. J'aurais donc une classe abstraite AbstraiteForme qui défini les méthodes de base telle que "setShader()", "setPosition()", etc. Par contre, la méthode dessiner() ne pourra pas être fournit par la classe abstraite. Donc cercle et carré auront a redéfinir comment elle voudront se déssiner. Les classes abstraite évite de réécrire 100 fois le meme bout de code dans chaque forme. Aussi, tu pourrais avoir une classe qui s'occupe de faire le draw. Avec une interface (ou une classe abstraite) ta pas besoin de savoir si tu va faire "dessiner()" sur un cercle ou un carré, tu sais juste que c'est une AbstraiteForme ou FormeIF et que ca ce dessine... Tu peux donc facilement ajouter ou retirer des forme dans ton système! :D Alors... la "factorisation"... c'est hyper puissant et ca sauve bcp de sous en dev (surtout coté maintenance!)
J'espere que c'est assez clair ;)