Tableau de comparaison
| Base de comparaison | Interface | Classe abstraite |
|---|---|---|
| De base | Lorsque vous ne connaissez que les exigences et non pas sa mise en oeuvre, vous utilisez "Interface". | Lorsque vous connaissez partiellement les implémentations, vous utilisez des "classes abstraites". |
| Les méthodes | L'interface ne contient que des méthodes abstraites. | La classe abstraite contient des méthodes abstraites ainsi que des méthodes concrètes. |
| Modificateur d'accès aux méthodes | Les méthodes d'interface sont toujours "Public" et "Résumé", même si nous ne le déclarons pas. Par conséquent, on peut dire qu'il s'agit d'une classe abstraite pure à 100%. | Il n'est pas obligatoire que la méthode en classe abstraite soit publique et abstraite. Il peut aussi avoir des méthodes concrètes. |
| Modificateur restreint pour les méthodes | Une méthode d'interface ne peut pas être déclarée avec les modificateurs suivants: Public: privé et protégé Résumé: final, statique, synchronisé, natif, strictfp. | Il n'y a pas de restrictions sur les modificateurs de la variable de classe abstraite. |
| Modificateur d'accès aux variables | Le modificateur d'accès autorisé pour les variables d'interface est public, statique et final, que nous déclarions ou non. | Les variables de la classe abstraite ne doivent pas nécessairement être publiques, statiques, finales. |
| Modificateurs restreints pour les variables | Les variables d'interface ne peuvent pas être déclarées comme privées, protégées, transitoires ou volatiles. | Il n'y a aucune restriction sur les modificateurs de variables de classe abstraites. |
| Initialisation de variables | Les variables d'interface doivent être initialisées au moment de sa déclaration. | Les variables de classe abstraites ne doivent pas obligatoirement être initialisées au moment de leur déclaration. |
| Instance et blocs statiques | Dans l'interface, vous ne pouvez pas déclarer une instance ou un bloc statique. | La classe abstraite autorise une instance ou un bloc statique à l'intérieur de celle-ci. |
| Constructeurs | Vous ne pouvez pas déclarer le constructeur à l'intérieur de l'interface. | Vous pouvez déclarer un constructeur dans une classe abstraite. |
Définition d'interface
Java n'autorise pas l'héritage multiple. Autrement dit, une classe unique ne peut pas hériter de plus d'une classe à la fois. La raison derrière cela peut être expliquée avec un exemple. Supposons que nous ayons deux classes mères, A et B et une classe dérivée C. La classe dérivée C hérite à la fois des classes A et B. Maintenant, les deux classes ont les classes A et B ont method set (), alors ce sera une question. pour la classe C, la méthode set () de cette classe devrait hériter. La solution à ce problème est "interface".
access_specifier interface nom_interface {type-retour nom-méthode1 (liste-paramètres); type-retour nom-méthode2 (liste-paramètres); type final-varname1 = valeur; type final-varname2 = valeur; // ... type de retour nom-méthodeN (liste de paramètres); type final-varnameN = valeur; } Le spécificateur d'accès est déclaré public car les classes doivent implémenter l'interface.
Nous n'avons pas le concept d'interface en C ++. Mais, Java et C # définissent très bien l'interface.
Interface en Java:
- Les variables d'une interface sont par défaut toujours publiques, statiques et finales.
- Les variables doivent être initialisées au moment de sa déclaration.
- Les variables ne peuvent jamais être déclarées comme privées, protégées, transitoires et volatiles.
- Les méthodes d'une interface sont toujours publiques et abstraites, alors qu'elles ne peuvent jamais être déclarées comme privées, protégées, finales, statiques, synchronisées, natives et strictfp.
- Vous ne pouvez pas déclarer de constructeur à l'intérieur de l'interface car l'objectif principal du constructeur est l'initialisation des variables de classe, mais, dans l'interface, les variables sont initialisées au moment de sa déclaration.
- L'interface peut hériter d'autres interfaces, mais la classe implémentant cette interface doit implémenter les méthodes de toutes les interfaces héritées.
- Une classe peut hériter de plusieurs interfaces à la fois et doit implémenter toutes les méthodes de toutes les interfaces héritées.
La forme générale d'implémentation d'une interface en Java:
class nom_classe implémente nom_interface {// corps de classe} Pour hériter d'une interface, une classe utilise un mot clé «implément», et la classe implémente toutes les méthodes déclarées par une interface héritée.
Interface en C #:
Les interfaces en C # sont presque similaires aux interfaces en Java, sauf que:
- L'interface en C # ne déclare pas de variables.
- Le nom de l'interface porte le préfixe I et est hérité du signe deux-points (:).
La forme générale d'implémentation d'une interface en C #:
class nom_classe: nom_interface {// corps de classe} Définition de la classe abstraite
Une classe qui contient une ou plusieurs méthodes abstraites est appelée classe abstraite. Une classe est déclarée comme abstraite à l'aide du mot clé «abstract», précédé du mot clé «class» au début de la déclaration de classe. Comme la classe abstraite contient la méthode abstraite, elle constitue un type incomplet. Par conséquent, vous ne pouvez pas créer d'objets d'une classe abstraite. Chaque fois qu'une classe hérite d'une classe abstraite, elle doit implémenter toutes les méthodes abstraites de la classe abstraite. Elle doit également être déclarée comme abstraite. L'attribut abstrait est hérité jusqu'à ce que la mise en œuvre complète des méthodes abstraites soit réalisée.
La classe abstraite peut également contenir des méthodes concrètes que la classe dérivée peut utiliser. Cependant, vous ne pouvez pas déclarer un constructeur abstrait ou une méthode statique abstraite dans une classe abstraite. La forme générale de la classe abstraite en Java est la suivante:
classe abstraite nom_classe {nom_méthode abstraite1 (); méthode_nom abstraite2 (); : return_type nom_méthode3 (liste_paramètres) {// méthode concrète} type_retour_nom_méthode4 (liste_paramètres) {// méthode concrète}}; Le concept de classe abstraite est similaire en Java et en C #. Une classe abstraite est légèrement différente en C ++.
En C ++, si une classe a au moins une fonction virtuelle, elle devient une classe abstraite. Au lieu du mot clé «abstract», le mot clé «virtual» est utilisé pour déclarer une méthode abstraite.
Principales différences entre les classes Interface et Abstract en Java et C #
- Lorsque vous connaissez «ce qui est requis» mais pas «comment il serait mis en œuvre», l'interface doit être utilisée. D'autre part, si vous savez ce qui est requis et savez en partie comment cela serait implémenté, utilisez une classe abstraite.
- Une interface a toutes ses méthodes abstraites mais une classe abstraite a des méthodes abstraites et des méthodes concrètes.
- Les méthodes à l'intérieur d'une interface sont publiques et abstraites. Par conséquent, elle est également appelée classe abstraite pure. D'autre part, les méthodes à l'intérieur d'un résumé ne sont pas limitées au public et à l'abstrait.
- Une méthode d'interface ne peut jamais être privée, protégée, finale, statique, synchronisée, native ou strictfp. D'autre part, il n'y a pas de restrictions aux méthodes d'une classe abstraite.
- Les variables dans une interface sont publiques et finales, que nous les déclarions ou non, alors qu’il n’existe pas de restriction de ce type aux variables d’une classe abstraite.
- Les variables dans une interface ne peuvent jamais être privées protégées transitoires ou volatiles alors qu'il n'y a pas de restriction aux variables dans une classe abstraite.
- La variable d'une interface doit être initialisée lors de la déclaration. D'autre part, les variables d'une classe abstraite peuvent être initialisées à tout moment.
- Dans une interface, une instance ou un bloc statique ne peut pas être déclaré, mais vous pouvez déclarer une instance ou un bloc statique dans une classe abstraite.
- Vous ne pouvez pas définir un constructeur dans une interface alors que vous pouvez définir un constructeur dans une classe abstraite.
Conclusion:
Lorsque vous devez créer une classe de base contenant une forme généralisée de méthodes pouvant être implémentées par les classes dérivées en fonction de leurs besoins, le concept d'interface et de classe abstraite vous aide à le faire.
