Différences entre la classe abstraite et l'interface dans Java

Abstraction Class vs Interface en Java

Pour comprendre les différences entre la classe abstraite et l'interface en Java, il est important de comprendre chacun de ces éléments indépendants. La classe abstraite de Java est utilisée dans la déclaration de sous-classes avec un ensemble de caractéristiques communes. L'utilisation courante de la classe abstraite est une super classe d'autres classes qui, en fait, lui permet d'étendre la classe abstraite. Un mot-clé abstrait est utilisé dans la déclaration d'une classe abstraite. Tout comme toute autre classe l'aurait fait, la classe abstraite a des champs qui décrivent les méthodes et les caractéristiques que la classe peut effectuer. Par la simple déclaration d'une classe abstraite, la classe ne peut être initiée

Une interface Java peut être assimilée à un protocole. Il représente un comportement préréglé et convenu qui permet de faciliter l'interaction d'objets non apparentés. Selon l'utilisateur, l'interface maintient la clé de différentes actions en cours d'implémentation. L'interface sert donc de lien entre le producteur et le consommateur. Les interfaces en Java sont donc un groupe de méthodes contenant des corps vides qui peuvent avoir des déclarations constantes. En exposant une classe à l'interface Java, cela signifie que le comportement attendu de la classe est la mise en œuvre de toutes les méthodes de l'interface.

Différences

Tout d'abord, une classe abstraite permet des champs qui ne sont pas statiques ou définitifs par opposition aux champs statiques et finaux utilisés dans les interfaces. Les interfaces ne peuvent avoir aucun code d'implémentation qui y est utilisé, et il peut y avoir un code d'implémentation utilisé dans la classe abstraite. Les codes d'implémentation déployés dans la classe abstrait peuvent avoir quelques ou toutes les méthodes implémentées. Par défaut, toutes les méthodes de l'interface sont «Résumé."

La visibilité est également possible pour les méthodes ou les membres d'une classe abstraite qui peut varier comme le public, protégé, privé ou aucun. La visibilité de l'interface, en revanche, ne peut être prédéfinie qu'à un seul mode de visibilité qui est «public.'"

Une classe abstraite héritera automatiquement de la classe d'objets. Cela signifie en effet que des méthodes telles que clone () et equals () sont incluses. Dans une interface, aucun héritage de la classe d'objets n'est possible. Après cela, la classe abstraite a la capacité d'avoir un constructeur, mais une interface ne peut pas en avoir une.

L'interface de Java a également une fonction très importante avec la mise en œuvre de plusieurs héritages car une classe ne peut avoir qu'une seule classe. Bien qu'une seule super classe puisse être présente, elle peut être mise en œuvre dans n'importe quel nombre d'interfaces. Il n'est pas possible d'avoir plusieurs héritages dans une classe abstraite.

En performance, les interfaces ont tendance à être plus lentes dans la mise en œuvre par opposition à la classe abstraite principalement en raison de la direction supplémentaire de trouver la méthode correspondante dans une classe. La différence, cependant, est devenue plus lente en raison de machines virtuelles Java modernes qui sont continuellement améliorées.

L'ajout d'une méthode dans une interface vous oblige à retrouver toutes les classes d'implémentation qui implémentent l'interface spécifique. Alternativement, vous pouvez étendre l'interface afin de lui permettre d'avoir des méthodes supplémentaires. Si vous avez affaire à une classe abstraite, tout ce qui est requis est d'ajouter l'implémentation par défaut de la méthode et le code continue de fonctionner. Dans la mesure où des différences existent entre les classes abstraites et les interfaces, il est important de noter qu'ils ne sont pas des rivaux, mais les différences mentionnées ici servent à se compléter mutuellement.  

Résumé

1. Les champs de classe abstraits ne sont pas statiques ou définitifs par opposition à l'interface qui a des tables statiques et finales.

2. Aucun code d'implémentation ne peut être utilisé dans les interfaces alors qu'il peut être utilisé dans la classe abstraite.

3. La visibilité de l'interface ne peut être publique que tandis que la visibilité de la classe abstraite peut varier.

4. Une classe abstraite héritera automatiquement de la classe d'objets, mais elle n'est pas possible dans l'interface.

5. La classe abstraite est plus rapide que l'interface dans l'implémentation.