Différence entre une classe abstraite et une interface en Java

La différence entre la Classe Abstraite et l’Interface est l’une des questions d’entretien les plus populaires. La Classe Abstraite et l’Interface sont une partie essentielle du langage de programmation Java. Que choisir entre une interface ou une classe abstraite est une décision de conception à laquelle chaque architecte est confronté. Dans mes derniers articles, j’ai fourni autant de détails que possible sur l’interface java et la classe abstraite. Dans ce post, nous allons apprendre la différence entre la classe abstraite et l’Interface et quand devrions-nous utiliser l’interface à la place de la classe abstraite et vice versa.

Différence entre Classe Abstraite et Interface

1. Le mot-clé abstract est utilisé pour créer une classe abstraite et il peut aussi être utilisé avec des méthodes alors que le mot-clé interface est utilisé pour créer une interface et il ne peut pas être utilisé avec des méthodes.
2. Les sous-classes utilisent le mot-clé extends pour étendre une classe abstraite et elles doivent fournir l’implémentation de toutes les méthodes déclarées dans la classe abstraite à moins que la sous-classe ne soit elle-même une classe abstraite alors que les sous-classes utilisent le mot-clé implements pour implémenter des interfaces et doivent fournir l’implémentation pour toutes les méthodes déclarées dans l’interface.
3. Les classes abstraites peuvent avoir des méthodes avec implémentation, tandis que l’interface fournit une abstraction absolue et ne peut avoir aucune implémentation de méthode. Notez qu’à partir de Java 8, nous pouvons créer des méthodes par défaut et statiques dans une interface qui contient les implémentations de méthodes.
4. Les classes abstraites peuvent avoir des constructeurs, mais les interfaces ne peuvent pas avoir de constructeurs.
5. Une classe abstraite a toutes les fonctionnalités d’une classe Java normale, sauf que nous ne pouvons pas l’instancier. Nous pouvons utiliser le mot-clé abstract pour rendre une classe abstraite, mais les interfaces sont un type complètement différent et peuvent avoir uniquement des constantes publiques, statiques et finales, ainsi que des déclarations de méthodes.
6. Les méthodes des classes abstraites peuvent avoir des modificateurs d’accès tels que public, privé, protégé, statique, mais les méthodes d’interface sont implicitement publiques et abstraites. Nous ne pouvons pas utiliser d’autres modificateurs d’accès avec les méthodes d’interface.
7. A subclass can extend only one abstract class but it can implement multiple interfaces.
8. Les classes abstraites peuvent étendre d’autres classes et implémenter des interfaces, mais une interface ne peut étendre que d’autres interfaces.
9. Nous pouvons exécuter une classe abstraite si elle a une méthode main(), mais nous ne pouvons pas exécuter une interface car elles ne peuvent pas avoir d’implémentation de méthode principale.
10. Les interfaces sont utilisées pour définir un contrat pour les sous-classes, tandis que la classe abstraite définit également un contrat mais peut fournir d’autres implémentations de méthodes pour que les sous-classes les utilisent.

C’est tout pour la différence entre une interface et des classes abstraites, maintenant nous pouvons passer à savoir quand utiliser une interface plutôt qu’une classe abstraite et vice versa.

Interface ou Classe Abstraite

Le choix entre une interface ou une classe abstraite pour fournir un contrat aux sous-classes est une décision de conception qui dépend de nombreux facteurs. Voyons quand les interfaces sont le meilleur choix et quand nous pouvons utiliser des classes abstraites.

1. Java ne prend pas en charge l’héritage de plusieurs classes, donc chaque classe peut étendre uniquement une superclasse. Mais une classe peut implémenter plusieurs interfaces. Donc la plupart du temps, les interfaces sont un bon choix pour fournir la base de la hiérarchie des classes et du contrat. De plus, coder en termes d’interfaces est l’une des meilleures pratiques de codage en Java.
2. Si le contrat comporte un grand nombre de méthodes, alors la classe abstraite est plus utile car nous pouvons fournir une implémentation par défaut pour certaines des méthodes communes à toutes les sous-classes. De plus, si les sous-classes n’ont pas besoin d’implémenter une méthode particulière, elles peuvent éviter de fournir l’implémentation, mais dans le cas d’une interface, la sous-classe devra fournir l’implémentation de toutes les méthodes même si cela n’a aucune utilité et que l’implémentation est simplement un bloc vide.
3. Si notre contrat de base change constamment, les interfaces peuvent poser des problèmes car nous ne pouvons pas déclarer de méthodes supplémentaires dans l’interface sans modifier toutes les classes d’implémentation, avec la classe abstraite, nous pouvons fournir l’implémentation par défaut et ne modifier que les classes d’implémentation qui vont réellement utiliser les nouvelles méthodes.

Utilisez à la fois des classes abstraites et des interfaces

L’utilisation conjointe d’interfaces et de classes abstraites est la meilleure approche pour concevoir un système. Par exemple, dans JDK java.util.List est une interface qui contient de nombreuses méthodes, donc il existe une classe abstraite java.util.AbstractList qui fournit une implémentation squelettique pour toutes les méthodes de l’interface List afin que toute sous-classe puisse étendre cette classe et implémenter uniquement les méthodes requises. Nous devrions toujours commencer par une interface comme base et définir les méthodes que chaque sous-classe devrait implémenter, puis s’il y a des méthodes que seule certaines sous-classes devraient implémenter, nous pouvons étendre l’interface de base et créer une nouvelle interface avec ces méthodes. Les sous-classes auront alors le choix entre l’interface de base ou l’interface enfant à implémenter selon leurs besoins. Si le nombre de méthodes devient très important, ce n’est pas une mauvaise idée de fournir une classe abstraite squelettique implémentant l’interface enfant et offrant ainsi de la flexibilité aux sous-classes pour choisir entre une interface et une classe abstraite.

Changements d’interface Java 8

À partir de Java 8, nous pouvons avoir des implémentations de méthodes dans les interfaces. Nous pouvons créer des méthodes par défaut ainsi que des méthodes statiques dans les interfaces et leur fournir une implémentation. Cela a comblé le fossé entre les classes abstraites et les interfaces et maintenant les interfaces sont la voie à suivre car nous pouvons les étendre davantage en fournissant des implémentations par défaut pour de nouvelles méthodes. Pour plus de détails, consultez Java 8 interface default static methods.