Différence de clé: une interface ou un protocole est un moyen courant permettant à des objets non liés de communiquer entre eux. Il représente un comportement convenu qui facilite l’interaction entre les deux objets. Une classe abstraite est une classe d'objets qui ne peuvent pas être instanciés ni configurer une instance d'objet. Cette classe peut ne pas avoir d'implémentation ou peut avoir une implémentation incomplète.

Java, C ++, C # sont tous des langages de programmation compliqués qui nécessitent une étude et une compréhension approfondies pour pouvoir travailler. De nombreuses méthodes différentes utilisées dans ces langues déterminent le fonctionnement de la langue. Interface et classe abstraite sont deux concepts déroutants faisant partie de la programmation orientée objet. Ces deux peuvent être utilisés individuellement ou ensemble. Ces deux sont complètement différents les uns des autres et sont utilisés dans des cas différents.

Java est un langage de programmation influencé par le langage C. Une grande partie de sa syntaxe provient du C et du C ++, mais il dispose de moins de fonctionnalités de bas niveau que les deux. Java est un langage de programmation généraliste conçu pour avoir moins de dépendances d'implémentation par rapport aux langages précédents. C'est un langage simultané, basé sur les classes et orienté objet.

Java a été développé par James Gosling chez Sun Microsystems et a été publié en 1995. Il a été initialement publié en tant que composant principal de la plate-forme Java de Sun Microsystems. Depuis, Sun a de nouveau licencié la plupart de ses technologies Java sous la licence publique générale GNU. Cela signifie que toutes les technologies sous licence GNU General Public License sont open source et généralement disponibles gratuitement. Sun Microsystems a finalement fusionné avec Oracle Corporation. Depuis 2012, Java est devenu l'un des langages de programmation les plus populaires. Cela est particulièrement vrai pour les applications Web client-serveur. De nombreux autres systèmes ont développé des implémentations alternatives des technologies Sun, telles que GNU Compiler for Java et GNU Classpath.

L'interface ou un protocole est un moyen courant permettant à des objets non liés de communiquer entre eux. Il représente un comportement convenu qui facilite l’interaction entre les deux objets. L'interface contient la clé des différentes actions mises en œuvre et sert de lien entre les deux objets. Si une classe d'objets est exposée à l'interface, celle-ci devra suivre le comportement mis en œuvre par l'interface. Généralement, les interfaces ne contiennent que des déclarations de constantes et des signatures de méthodes. Toute interface qui implémente une interface particulière doit appliquer toutes les méthodes mentionnées dans l'interface ou être déclarée en tant que classe abstraite. En Java, tout objet peut être défini en tant qu'interface, si cet objet est null ou contient une classe dans laquelle il implémente cette interface particulière. Il est possible d'implémenter plusieurs interfaces dans une même classe en Java à l'aide de mots-clés implémenter.

Une classe abstraite est une classe d'objets qui ne peuvent pas être instanciés ni configurer une instance d'objet. Cette classe peut ne pas avoir d'implémentation ou peut avoir une implémentation incomplète. Il peut également avoir des méthodes abstraites ou des propriétés partagées par toutes les sous-classes. Dans certains langages de programmation, les types abstraits sans implémentation sont appelés interfaces. En Java, un type abstrait peut être créé à l'aide du mot clé 'abstract' dans la définition de la classe. Avoir une classe abstraite pour placer toutes les méthodes qui ne sont pas implémentées dans la classe abstraite et laisser le soin à la sous-classe de déterminer comment implémenter ces classes. Si une classe a une seule méthode abstraite, elle doit être déclarée en tant que classe abstraite, bien qu'il ne soit pas nécessaire d'avoir au moins une seule méthode pour déclarer un abstrait de classe.

Malliktalksjava.in énumère les principales différences entre interface et abstract comme suit:

• La classe abstraite a le constructeur, mais pas l'interface.
• Les classes abstraites peuvent avoir des implémentations pour certains de leurs membres (Méthodes), mais l'interface ne peut pas avoir d'implémentation pour aucun de ses membres.
• Les classes abstraites devraient avoir des sous-classes qui seraient inutiles.
• Les interfaces doivent avoir des implémentations par d'autres classes qui seront inutiles
• Seule une interface peut étendre une autre interface, mais toute classe peut étendre une classe abstraite.
• Toutes les variables dans les interfaces sont finales par défaut
• Les interfaces fournissent une forme d'héritage multiple. Une classe ne peut étendre qu'une autre classe.
• Les interfaces sont limitées aux méthodes et aux constantes publiques sans implémentation. Les classes abstraites peuvent avoir une implémentation partielle, des parties protégées, des méthodes statiques, etc.
• Une classe peut implémenter plusieurs interfaces. Mais en cas de classe abstraite, une classe ne peut étendre qu'une classe abstraite.
• Les interfaces sont lentes car il faut plus d'indirection pour trouver la méthode correspondante dans la classe réelle. Les classes abstraites sont rapides.
• Le modificateur d'accessibilité (public / privé / interne) est autorisé pour les classes abstraites. L'interface n'autorise pas le modificateur d'accessibilité
• Une classe abstraite peut contenir des méthodes complètes ou incomplètes. Les interfaces ne peuvent contenir que la signature d'une méthode, mais pas de corps. Ainsi, une classe abstraite peut implémenter des méthodes mais une interface ne peut pas implémenter des méthodes.
• Une classe abstraite peut contenir des champs, des constructeurs ou des destructeurs et implémenter des propriétés. Une interface ne peut pas contenir de champs, de constructeurs ou de destructeurs et ne comporte que la signature de la propriété, mais aucune implémentation.
• Divers modificateurs d'accès tels que résumé, protégé, interne, public, virtuel, etc. sont utiles dans les classes abstraites, mais pas dans les interfaces.
• La portée abstraite est à la classe dérivée.
• La portée de l'interface est à n'importe quel niveau de sa chaîne d'héritage.

Les informations pour la table sont la courtoisie de codeproject.com et mindprod.com

	Interface	Classe abstraite
Héritage multiple	Une classe peut hériter de plusieurs interfaces.	Une classe ne peut hériter que d'une classe abstraite.
Implémentation par défaut	Une interface ne peut fournir aucun code, juste la signature.	Une classe abstraite peut fournir un code complet par défaut et / ou uniquement les détails à remplacer.
Modificateurs d'accès	Une interface ne peut pas avoir de modificateurs d’accès pour les sous-programmes, fonctions, propriétés, etc. Tout est supposé public.	Une classe abstraite peut contenir des modificateurs d'accès pour les sous-fonctions, fonctions et propriétés.
Core vs. Périphérique	Les interfaces sont utilisées pour définir les capacités périphériques d'une classe. En d'autres termes, Human et Vehicle peuvent hériter d'une interface IMovable.	Une classe abstraite définit l'identité principale d'une classe et est utilisée pour les objets du même type.
Homogénéité	Si différentes implémentations ne partagent que des signatures de méthodes, il est préférable d'utiliser des interfaces.	Si différentes implémentations sont du même type et utilisent un comportement ou un statut commun, il est préférable d'utiliser une classe abstraite.
La vitesse	Nécessite plus de temps pour trouver la méthode dans les classes correspondantes.	Vite
Ajout de fonctionnalités	Si nous ajoutons une nouvelle méthode à une interface, nous devons localiser toutes les implémentations de l'interface et définir l'implémentation de la nouvelle méthode.	Si nous ajoutons une nouvelle méthode à une classe abstraite, nous avons la possibilité de fournir une implémentation par défaut. Par conséquent, tout le code existant peut fonctionner correctement.
Champs et constantes	Aucun champ ne peut être défini dans les interfaces.	Une classe abstraite peut avoir des champs et des constantes définis.
Laconisme	Les déclarations de constantes dans une interface sont toutes présumées publiques statiques finales.	Le code partagé peut être ajouté dans une classe abstraite.
Constantes	Les constantes finales statiques uniquement peuvent être utilisées sans qualification dans les classes qui implémentent l'interface.	Les constantes d'instance et statiques sont possibles. Il est également possible de calculer les constantes à l'aide d'un code d'initialisation statique et d'instance.
Commodité de tiers	Une implémentation d'interface peut être ajoutée à toute classe tierce existante.	Une classe tierce doit être réécrite pour s'étendre uniquement à partir de la classe abstraite.
est-un vs -able ou peut-faire	Les interfaces sont souvent utilisées pour décrire les capacités périphériques d'une classe, et non son identité centrale. Par exemple, une classe Automobile peut implémenter l'interface Recyclable, ce qui pourrait s'appliquer à de nombreux objets sans aucun lien.	Une classe abstraite définit l'identité principale de ses descendants. Les interfaces implémentées énumèrent les tâches générales d'une classe, et non celles d'une classe. Dans un contexte Java, les utilisateurs doivent généralement implémenter l'interface Runnable plutôt que d'étendre Thread, car ils ne sont pas vraiment intéressés par une nouvelle fonctionnalité de Thread. Ils souhaitent simplement que certains codes puissent être exécutés indépendamment. Ils veulent créer quelque chose qui peut être exécuté dans un fil, pas un nouveau type de fil. Le même débat est un contre a et un débat survient lorsque vous décidez d'hériter ou de déléguer.
Brancher	L'utilisateur peut écrire un nouveau module de remplacement pour une interface ne contenant pas une seule clé de code en commun avec les implémentations existantes. Lorsque l'utilisateur implémente l'interface, il commence à zéro, sans aucune implémentation par défaut. L'utilisateur doit obtenir des outils d'autres classes. l'interface ne contient rien d'autre que quelques constantes. Cela donne à l'utilisateur la liberté de mettre en œuvre une conception interne radicalement différente.	L'utilisateur doit utiliser la classe abstraite telle quelle pour la base de code, avec tous ses bagages auxiliaires, bons ou mauvais. L'auteur de la classe abstraite a imposé une structure à l'utilisateur.
Entretien	Si le code client parle uniquement en termes d'interface, vous pouvez facilement modifier l'implémentation concrète derrière celle-ci, à l'aide d'une méthode fabrique.	Si le code client parle uniquement en termes de classe abstraite, vous pouvez facilement modifier l'implémentation concrète qui se trouve derrière celle-ci, à l'aide d'une méthode fabrique.