Comme nous le savons tous, l'abstraction fait référence à la mise en œuvre intérieure de la fonctionnalité et montre uniquement le côté pratique aux utilisateurs. c'est-à-dire ce que cela fonctionne (montrant, cependant, l'interface offre une abstraction complète en Java, ce que les catégories abstraites ne peuvent pas faire.
Classe abstraite vs interface
La principale différence entre la classe abstraite et l'interface est que l'interface associée étendra uniquement une autre interface Java ; la catégorie abstraite associée développera une autre catégorie Java et implémentera plusieurs interfaces Java. Les membres d'une interface Java diffèrent publiquement par défaut. Une catégorie abstraite Java aura des membres de catégorie comme personnel, protégé, etc.
Une classe abstraite est une classe qui possède le mot-clé abstract dans sa déclaration. Au moins une méthode abstraite, c'est-à-dire des méthodes sans corps, doit être présente dans les classes abstraites. Il peut s’agir de diverses méthodes concrètes.
Vous pouvez utiliser des classes abstraites pour générer des plans pour des classes concrètes. Cependant, la méthode abstraite doit être implémentée par la classe qui hérite.
L'interface est un modèle pour une classe qui peut être utilisée pour la créer. L'interface n'a pas de méthodes concrètes (méthodes qui ont du code). Les méthodes d'une interface sont toutes des méthodes abstraites.
Il n'est pas possible de créer une interface. En revanche, les classes qui implémentent des interfaces peuvent être instanciées. Les variables d'instance ne sont jamais utilisées dans les interfaces. Cependant, des variables finales statiques publiques (également appelées variables de classe constantes) peuvent être utilisées.
Qu'est-ce qu'une classe abstraite ?
Une classe abstraite est un concept fondamental de la programmation orientée objet (POO) qui sert de modèle ou de modèle pour d'autres classes. C'est une classe qui ne peut pas être instanciée et qui est destinée à être étendue ou sous-classée par d'autres classes. Les classes abstraites définissent des attributs et des méthodes communs que plusieurs classes associées partageront au sein d'une hiérarchie d'héritage.
Les principales caractéristiques et caractéristiques des classes abstraites comprennent :
- Ne peut pas être instancié : Une classe abstraite ne peut pas être utilisée pour créer directement des objets ou des instances. Au lieu de cela, il fournit un cadre permettant aux sous-classes d'hériter et d'implémenter ses propriétés et méthodes.
- Peut contenir des méthodes abstraites : Les classes abstraites incluent une ou plusieurs méthodes abstraites. Déclarations de méthode sans aucun détail d'implémentation. Les sous-classes doivent fournir des implémentations concrètes pour ces méthodes abstraites.
- Peut inclure des méthodes concrètes : Les classes abstraites peuvent également avoir des méthodes concrètes (entièrement implémentées) dont les sous-classes peuvent hériter. Ces méthodes peuvent fournir des fonctionnalités communes partagées par toutes les sous-classes.
- Utilisé pour la réutilisabilité du code : Les classes abstraites favorisent la réutilisabilité du code et le principe DRY (Don't Repeat Yourself) en permettant de définir du code commun dans une seule classe abstraite et de le partager entre des sous-classes associées.
- héritage: Les sous-classes héritent des attributs et méthodes définis dans une classe abstraite. Cela permet une spécialisation et une personnalisation des comportements tout en conservant une structure commune.
- Cours abstraits ou concrets : Les classes abstraites se distinguent des classes concrètes, qui peuvent être instanciées directement. Les classes concrètes fournissent des implémentations complètes pour toutes leurs méthodes.
Dans des langages comme Java et C#, le mot-clé « abstrait » définit des classes abstraites. Les classes abstraites sont des outils précieux pour créer des hiérarchies de classes apparentées partageant des caractéristiques et des comportements communs tout en permettant la personnalisation et la spécialisation dans les classes dérivées.
Qu'est-ce qu'Interface ?
Une interface est un concept fondamental de la programmation orientée objet (POO) qui définit un contrat ou un ensemble de signatures de méthode qui doivent être implémentées par toute classe adhérant à l'interface. Les interfaces offrent un moyen d'obtenir un héritage multiple dans des langages qui ne le prennent pas directement en charge et favorisent l'abstraction, la modularité et la flexibilité du code.
Les principales fonctionnalités et caractéristiques des interfaces comprennent :
- Signatures de méthode : Une interface définit une collection de signatures de méthodes sans détails d'implémentation. Ces signatures de méthodes représentent un ensemble de comportements que les classes d'implémentation doivent fournir.
- Obligation contractuelle: Lorsqu'une classe implémente une interface, elle doit fournir des implémentations concrètes pour toutes les méthodes définies dans cette interface. Ne pas le faire entraîne une erreur de compilation.
- Héritage multiple : Contrairement aux classes, qui prennent en charge l'héritage unique (extension d'une classe), une classe peut implémenter plusieurs interfaces. Cela permet à une classe d'hériter et de fournir plusieurs ensembles de comportements.
- Abstraction et polymorphisme : Les interfaces favorisent l'abstraction en séparant le « quoi » (signatures de méthodes) du « comment » (implémentations de méthodes). Cette abstraction permet le polymorphisme, où les objets de différentes classes implémentant la même interface peuvent être traités de manière interchangeable.
- Réutilisabilité du code : Les interfaces facilitent la réutilisabilité du code en définissant des comportements communs que diverses classes peuvent implémenter. Cela favorise le principe DRY (Don't Repeat Yourself).
- Flexibilité: Les interfaces permettent un code faiblement couplé en permettant aux classes d'être interchangeables en fonction des interfaces qu'elles implémentent. Cette flexibilité est particulièrement utile dans la conception de systèmes modulaires et extensibles.
Les interfaces sont largement utilisées dans des langages comme Java, C# et TypeScript pour définir et appliquer des contrats entre les classes, garantissant qu'elles adhèrent à une API (Application Programming Interface) spécifiée et partagent des comportements communs tout en permettant diverses implémentations.
Tableau de comparaison entre la classe abstraite et l'interface
| Paramètres de différenciation | Classe abstraite | Interfaces |
|---|---|---|
| Instanciation | Ne peut pas être instancié directement. | Il ne peut pas être instancié directement. |
| Objectif | Sert de modèle pour d'autres classes et peut fournir les deux déclarations de méthodes avec ou sans implémentations. | Il ne peut pas être instancié directement. |
| Méthodologie | Peut avoir des méthodes abstraites (non implémentées), des méthodes concrètes (implémentées) ou une combinaison des deux. | Contient uniquement les signatures de méthodes sans aucune implémentation ; toutes les méthodes sont implicitement abstraites. |
| Héritage multiple | Prend en charge l'héritage unique ; une classe ne peut étendre qu’une seule classe abstraite. | Prend en charge l'héritage multiple ; une classe peut implémenter plusieurs interfaces. |
| Constructeurs | Peut avoir des constructeurs, qui sont invoqués lorsqu'une instance de la sous-classe est créée. | Ne peut pas avoir de constructeurs car ils ne peuvent pas être instanciés directement. |
| Réutilisabilité du code | Favorise la réutilisabilité du code en permettant le partage du code commun entre les classes associées. | Favorise la réutilisabilité du code en définissant des ensembles communs de comportements que les classes doivent implémenter. |
| Flexibilité | Offre un équilibre entre l'abstraction et la fourniture de fonctionnalités communes. | Met l'accent sur l'abstraction et la spécification d'un contrat. |
| Cas d'usage | Utile pour créer des hiérarchies de classes associées avec un comportement et des attributs partagés. | Utile pour définir des contrats garantissant que les classes d’implémentation fournissent des comportements spécifiques. |
| Exemple | abstract class Shape { abstract double area(); } | interface Drawable { void draw(); } |
| Scénario | Utile lorsque vous souhaitez fournir une classe de base commune avec un comportement par défaut tout en laissant des méthodes spécifiques implémentées par les sous-classes. | Utile lorsque vous souhaitez définir un contrat ou un ensemble partagé de comportements entre plusieurs classes sans dicter une classe de base commune. |
Principales différences entre Classe abstraite et interface
Classe abstraite:
- Peut avoir à la fois des méthodes abstraites (non implémentées) et concrètes (implémentées).
- Prend en charge l'héritage unique, ce qui signifie qu'une classe ne peut étendre qu'une seule classe abstraite.
- Peut avoir des constructeurs pour initialiser les états des objets.
- Permet la création d'une classe de base avec un comportement par défaut.
- Fournit un équilibre entre l’abstraction et les fonctionnalités communes.
- Utile lors de la création de hiérarchies de classes associées avec des attributs et des comportements partagés.
Interface:
- Contient uniquement les signatures de méthodes sans aucune implémentation ; toutes les méthodes sont implicitement abstraites.
- Prend en charge l'héritage multiple, ce qui signifie qu'une classe peut implémenter plusieurs interfaces.
- Ne peut pas avoir de constructeurs, car les interfaces ne peuvent pas être instanciées.
- Définit un contrat spécifiant un ensemble de méthodes que les classes d'implémentation doivent fournir.
- Met l'accent sur l'abstraction et la spécification d'un ensemble partagé de comportements.
- Utile pour définir des contrats et garantir que les classes respectent les exigences spécifiques de l'API.
Conclusion
Une classe abstraite vous permet de créer des fonctionnalités que les sous-classes peuvent implémenter ou remplacer, tandis qu'une interface vous permet d'énoncer mais pas d'implémenter des fonctionnalités. Alors qu'une classe ne peut étendre qu'une seule classe abstraite, elle peut implémenter plusieurs interfaces.
Référence
- https://dl.acm.org/doi/abs/10.1145/1040305.1040314
- https://books.google.com/books?hl=en&lr=&id=8M3F_sSSvWkC&oi=fnd&pg=PR13&dq=+interface+java&ots=Qo15NiH18i&sig=Y6OESYd5a6G709ynnLGB4Ry97yU
J'ai mis tellement d'efforts à écrire ce billet de blog pour vous apporter de la valeur. Cela me sera très utile, si vous envisagez de le partager sur les réseaux sociaux ou avec vos amis/famille. LE PARTAGE C'EST ♥️
