Différences entre l'interface Java et la classe abstraite
Une interface spécifiera ce qu'une classe doit faire mais pas comment. Il s'agit essentiellement d'un plan pour la classe. Les variables déclarées dans une interface sont publiques, statiques et finales par défaut. Une classe déclarée par le mot clé «abstrait» est appelée classe abstraite Une classe dérivée de la classe abstraite doit définir toutes les méthodes déclarées abstraites dans une classe abstraite.
Qu'est-ce que l'interface?
Une interface est comme une classe mais ce n'est pas celle qui peut avoir des méthodes et des variables comme classe mais les méthodes déclarées dans une interface sont abstraites par défaut. Une interface est utilisée pour fournir une abstraction complète car les méthodes dans les interfaces n'ont pas de corps. Ils doivent donc être implémentés par la classe avant d'essayer d'y accéder. En général, une classe qui implémente une interface doit définir toutes les méthodes déclarées dans une interface si ce n'est pas le cas, alors la classe doit être déclarée abstraite. Nous ne pouvons pas étendre l'interface à plusieurs classes car Java ne le permet pas. Pour déclarer une interface, nous devons utiliser le mot-clé interface et pour implémenter l'interface, nous devons utiliser le mot-clé implements.
Qu'est-ce que l'abstrait?
Une classe qui est déclarée par le mot-clé «abstrait» est appelée une classe abstraite. Une classe abstraite peut avoir des méthodes abstraites (méthode sans corps) et concrètes (méthode avec corps), contrairement à une classe normale. La classe abstraite ne peut pas être instanciée, c'est-à-dire que nous ne pouvons pas créer d'objet pour elle, mais pouvons avoir des références à la classe abstraite en créant une autre classe qui étend la classe abstraite et fournit l'implémentation de méthodes. Nous pouvons utiliser un objet d'un enfant (qui est nouvellement créé) pour appeler des méthodes abstraites et normales. Elle peut avoir des constructeurs et la classe abstraite est appelée lorsqu'une instance de classe héritée est créée. En Java, nous pouvons avoir une classe abstraite sans mot-clé abstrait mais ces classes ne peuvent pas être instanciées, seulement héritées et peuvent également avoir des méthodes finales.
Comparaison directe entre l'interface Java et la classe abstraite (infographie)
Vous trouverez ci-dessous les 9 meilleures comparaisons entre l'interface Java et la classe abstraite 
Différences clés entre l'interface Java et la classe abstraite
L'interface Java et la classe abstraite sont des choix populaires sur le marché; laissez-nous discuter de quelques-unes des principales différences entre l'interface Java et la classe abstraite:
- Une interface peut être utilisée pour réaliser plusieurs héritages et couplages lâches que nous ne pouvons pas atteindre par la classe abstraite.
- Interface utilisée pour réaliser une abstraction complète alors qu'une classe abstraite peut réaliser une abstraction partielle.
- Une classe abstraite étend seulement une classe normale ou une classe abstraite à la fois tandis qu'une interface peut étendre n'importe quel nombre d'interfaces à la fois.
- Une classe abstraite étend une autre classe abstraite ou normale tandis qu'une interface ne peut étendre qu'une autre interface Java.
- Dans une classe abstraite, nous devons déclarer des méthodes en utilisant le mot clé «abstrait» alors que dans l'interface, nous pouvons déclarer des méthodes avec ou sans le mot clé «abstrait».
- Une interface ne peut avoir que des méthodes abstraites tandis qu'une classe abstraite peut avoir à la fois des classes abstraites et normales.
- Une classe abstraite peut avoir différentes variables comme statiques, finales, non finales, non statiques, publiques, privées, etc. tandis que l'interface ne peut avoir que des variables publiques, statiques et finales.
- Une classe abstraite et ses méthodes peuvent être créées par le mot clé "abstrait" tandis que le mot clé interface est utilisé pour créer une interface mais pas des méthodes.
- Une classe abstraite peut avoir des constructeurs alors que l'interface n'a pas de constructeur.
- Une classe abstraite est utilisée pour définir le contrat, les implémentations de méthode pour la sous-classe tandis qu'une interface est utilisée pour définir un contrat pour les sous-classes.
- Une interface ne peut étendre que d'autres interfaces Java tandis qu'une classe abstraite peut étendre une autre classe et implémenter une interface également.
- Une classe qui étend une classe abstraite à l'aide du mot-clé extend, doit implémenter toutes les méthodes déclarées dans la classe abstraite, sauf si une classe est également une classe abstraite, tandis que la classe qui implémente l'interface à l'aide du mot-clé interface fournit également une implémentation pour toutes les méthodes déclarées dans l'interface.
Tableau de comparaison Interface Java vs classe abstraite
Voici le tableau de comparaison entre l'interface Java et la classe abstraite
| La base de comparaison entre l'interface Java et la classe abstraite | Classe abstraite | Interface Java |
| Type de méthode | Une classe abstraite peut avoir à la fois des méthodes abstraites (méthodes sans corps) et non abstraites (méthodes avec corps) | Dans Interface, nous ne pouvons avoir que des méthodes abstraites. Depuis Java 8, l'interface peut également avoir des méthodes statiques et par défaut |
| Syntaxe | Une classe abstraite peut être déclarée comme suit: école publique de classe abstraite (classes publiques abstraites de vide (); force du vide abstraite publique ();) | Une interface peut être déclarée comme suit: forme de l'interface publique (Void draw_rect (); Void draw_square ();) |
| Variable finale | Une classe abstraite peut avoir des variables finales et non finales. | Alors que l'interface ne peut avoir que des variables finales car les variables sont finales par défaut dans l'interface. |
| la mise en oeuvre | Une classe abstraite peut fournir l'implémentation de toutes les méthodes abstraites dans l'interface. | Alors que dans l'interface, nous ne pouvons pas fournir l'implémentation d'une classe abstraite. |
| Type variable | Une classe abstraite peut tous les types de variables à savoir final, non final, statique, non statique, privé, public, etc. | Alors que l'interface ne peut avoir que des variables publiques, statiques et finales. |
| Accessibilité des membres de données | Une classe abstraite peut avoir des membres de classe privés, protégés, publics, etc. | Une interface ne peut avoir que des membres de classe publique car les membres de données d'interface sont publics par défaut. |
| Héritage vs abstraction | Une classe abstraite peut être étendue en utilisant le mot-clé «extend» et doit fournir l'implémentation de toutes les méthodes déclarées dans la classe parente ou la classe abstraite | Une interface peut être implémentée à l'aide du mot-clé «interface» et doit fournir l'implémentation de toutes les méthodes déclarées dans l'interface |
| Implémentation multiple | Une classe abstraite peut étendre une autre classe Java implémentant plusieurs interfaces | Une interface ne peut étendre qu'une autre interface. |
| Quand utiliser | Une classe abstraite doit être utilisée lorsque certaines classes doivent partager quelques lignes de code, alors nous pouvons mettre ces codes dans une classe abstraite et les étendre à toutes les classes liées. | Une interface peut être utilisée lorsque nous devons réaliser plusieurs héritages, une abstraction complète en implémentant toutes les méthodes déclarées dans une interface par une classe qui implémente l'interface. |
Conclusion - Interface Java vs classe abstraite
Enfin, c'est un aperçu de la différence entre l'interface Java et la classe abstraite. J'espère que vous aurez une meilleure compréhension de ces concepts d'interface Java vs classe abstraite. Sur la base de nos exigences, nous pouvons utiliser à la fois l'interface Java et la classe abstraite, uniquement l'interface et uniquement la classe abstraite. Mais utiliser des interfaces et une classe abstraite ensemble est la meilleure approche pour la conception. Lorsqu'une classe doit partager du code, nous pouvons placer ce code dans la classe abstraite et lorsqu'un état d'un objet est requis, nous pouvons l'obtenir en définissant des champs non statiques ou non finaux, nous pouvons alors utiliser une classe abstraite. Nous pouvons utiliser Interface lorsque nous avons besoin d'une abstraction complète, d'un héritage multiple et d'un couplage lâche.
Article recommandé
Cela a été un guide pour les principales différences entre l'interface Java et la classe abstraite. Ici, nous discutons également des différences clés entre l'interface Java et la classe abstraite avec des infographies et un tableau de comparaison. Vous pouvez également consulter les articles suivants -
- Quelle est l'utilité des questions et réponses d'entrevue C #?
- 8 Comparaison utile-HTML5 vs Flash
- Java vs C # - 8 différences importantes
- Ruby vs Node
- Comparaison HTML5 vs JavaScript
- ArrayList vs Java Vector