Quelle est la différence entre une classe d'interface et une classe abstraite?
Quelle est exactement la différence entre une classe d'interface et abstraite?
Des interfaces
Une interface est un contrat : la personne qui écrit l'interface dit: "hé, j'accepte les choses qui ressemblent à", et la personne qui utilise l'interface dit "OK, la classe que j'écris a l'air d'être façon".
Une interface est un shell vide . Il n'y a que les signatures des méthodes, ce qui implique que les méthodes n'ont pas de corps. L'interface ne peut rien faire. C'est juste un motif.
Par exemple (pseudo code):
// I say all motor vehicles should look like this:
interface MotorVehicle
{
void run();
int getFuel();
}
// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{
int fuel;
void run()
{
print("Wrroooooooom");
}
int getFuel()
{
return this.fuel;
}
}
L'implémentation d'une interface consomme très peu de ressources processeur, car ce n'est pas une classe, mais un groupe de noms, et il n'y a donc pas de recherche coûteuse à effectuer. C'est formidable quand c'est important, comme dans les appareils embarqués.
Classes abstraites
Les classes abstraites, contrairement aux interfaces, sont des classes. Leur utilisation est plus coûteuse, car il faut effectuer une recherche lorsque vous en héritez.
Les classes abstraites ressemblent beaucoup aux interfaces, mais elles ont quelque chose de plus: vous pouvez définir un comportement pour elles. Il s’agit plus d’une personne qui dit: "Ces classes devraient ressembler à cela, et elles ont ceci en commun, alors remplissez les blancs!".
Par exemple:
// I say all motor vehicles should look like this:
abstract class MotorVehicle
{
int fuel;
// They ALL have fuel, so lets implement this for everybody.
int getFuel()
{
return this.fuel;
}
// That can be very different, force them to provide their
// own implementation.
abstract void run();
}
// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
void run()
{
print("Wrroooooooom");
}
}
La mise en oeuvre
Bien que les classes abstraites et les interfaces soient supposées être des concepts différents, les implémentations rendent parfois cette déclaration fausse. Parfois, ils ne sont même pas ce que vous pensez qu'ils sont.
En Java, cette règle est fortement appliquée, alors qu'en PHP, les interfaces sont des classes abstraites sans méthode déclarée.
En Python, les classes abstraites sont plus une astuce de programmation que vous pouvez obtenir à partir du module ABC et utilise en fait des métaclasses, et donc des classes. Et les interfaces sont plus liées au typage de canard dans ce langage et c'est un mélange de conventions et de méthodes spéciales qui appellent des descripteurs (les méthodes __method__).
Comme d'habitude avec la programmation, il y a théorie, pratique et pratique dans une autre langue :-)
Les principales différences techniques entre une classe abstraite et une interface sont les suivantes:
Les classes abstraites peuvent avoir constantes, membres, stubs de méthodes (méthodes sans corps) et méthodes définies, alors que les interfaces ne peuvent avoir que constantes et stubs de méthodes.
Les méthodes et les membres d'une classe abstraite peuvent être définis avec toute visibilité, tandis que toutes les méthodes d'une interface doivent être définies en tant que
public(elles sont définies par défaut comme publiques).Lors de l'héritage d'une classe abstraite, une classe concrète enfant _ doit définir les méthodes abstraites}, alors qu'une classe abstraite peut étendre une autre classe abstraite et que les méthodes abstraites de la classe parente défini.
De même, une interface qui étend une autre interface est non responsable de la mise en œuvre des méthodes de l'interface parent. En effet, les interfaces ne peuvent définir aucune implémentation.
Une classe enfant ne peut que étendre une seule classe (abstraite ou concrète), alors qu'une interface peut être étendue ou qu'une classe peut implémenter plusieurs autres interfaces.
Une classe enfant peut définir des méthodes abstraites avec la visibilité identique ou moins restrictive, tandis qu'une classe implémentant une interface doit définir les méthodes avec la même visibilité (publique).
Une interface ne contient que la définition/signature de la fonctionnalité, et si nous avons des fonctionnalités communes ainsi que des signatures communes, nous devons utiliser une classe abstraite. En utilisant une classe abstraite, nous pouvons fournir un comportement ainsi que des fonctionnalités à la fois. Un autre développeur qui hérite de la classe abstraite peut facilement utiliser cette fonctionnalité, car il lui suffirait de remplir les blancs.
Pris à partir de:
http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html
http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.htmlhttp://www.dotnetbull.com/2011/ 11/ce-que-est-interface-en-c-net.html
Une explication peut être trouvée ici: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm
Une classe abstraite est une classe qui est que partiellement implémenté par le programmeur. Il peut contenir un ou plusieurs méthodes abstraites. Une méthode abstraite est simplement une définition de fonction qui sert à dire au programmeur que le La méthode doit être implémentée dans un enfant classe.
Une interface est similaire à un résumé classe; en effet les interfaces occupent le même espace de noms que les classes et abstract Des classes. Pour cette raison, vous ne pouvez pas définir une interface avec le même nom en tant que classe. Une interface est entièrement classe abstraite; aucune de ses méthodes sont mis en œuvre et à la place d'une classe en sous-classant, on dit de mettre en œuvre cette interface.
Quoi qu'il en soit, je trouve cette explication des interfaces quelque peu déroutante. Une définition plus courante est la suivante: Une interface définit un contrat que la mise en œuvre de classes doit remplir. Une définition d'interface est composée des signatures des membres du public, sans code d'implémentation.
Je ne veux pas souligner les différences qui ont déjà été mentionnées dans de nombreuses réponses (concernant les modificateurs finaux statiques publics pour les variables dans l'interface et le support des méthodes protégées et privées dans les classes abstraites)
En termes simples, je voudrais dire:
interface: Pour implémenter un contrat avec plusieurs objets indépendants
classe abstraite: Pour implémenter le même comportement ou un comportement différent parmi plusieurs objets liés
Depuis Oracle documentation
Envisagez d'utiliser des classes abstraites si:
- Vous souhaitez partager du code entre plusieurs classes étroitement liées.
- Vous vous attendez à ce que les classes qui étendent votre classe abstraite aient de nombreuses méthodes ou champs communs, ou nécessitent des modificateurs d'accès autres que public (tels que protected et private).
- Vous voulez déclarer des champs non statiques ou non finaux.
Pensez à utiliser les interfaces si:
- Vous vous attendez à ce que des classes non liées implémentent votre interface. Par exemple, de nombreux objets non liés peuvent implémenter l'interface
Serializable. - Vous souhaitez spécifier le comportement d'un type de données particulier, sans vous soucier de savoir qui l'implémente.
- Vous souhaitez tirer parti de l'héritage multiple de type.
classe abstraite établit "est une" relation avec des classes concrètes. l'interface fournit "a" une capacité pour les classes.
Si vous recherchez Java comme langage de programmation, voici quelques nouvelles mises à jour:
Java 8 a réduit dans une certaine mesure l'écart entre les classes interface et abstract en fournissant une fonctionnalité de méthode default. Une interface n'a pas d'implémentation car une méthode n'est plus valide maintenant.
Reportez-vous à cette documentation page pour plus de détails.
Examinez cette question SE pour des exemples de code afin de mieux comprendre.
Comment aurais-je dû expliquer la différence entre une classe d'interface et une classe abstraite?
Quelques différences importantes:
Sous forme de tableau:
Comme a déclaré par Joe de javapapers :
1.La principale différence est que les méthodes d'une interface Java sont implicitement abstraites et ne peuvent pas avoir d'implémentations. Une classe abstraite Java peut ont des méthodes d'instance qui implémentent un comportement par défaut.
2.Les variables déclarées dans une interface Java sont par défaut définitives. Une classe abstraite peut contenir des variables non finales.
3.Les membres d'une interface Java sont publics par défaut. Une classe abstraite Java peut avoir les saveurs habituelles des membres de classe comme private, protégé, etc.
4. L’interface Java doit être implémentée à l’aide du mot clé «implément»; Une classe abstraite Java doit être étendue à l'aide du mot clé «extend».
5.Une interface peut uniquement étendre une autre interface Java, une classe abstraite peut étendre une autre classe Java et implémenter plusieurs Java interfaces.
6.Une classe Java peut implémenter plusieurs interfaces, mais elle ne peut étendre qu'une seule classe abstraite.
7.Interface est absolument abstrait et ne peut être instancié. Une classe abstraite Java ne peut pas non plus être instanciée, mais peut être invoquée s'il s'agit d'un main () existe.
8.En comparaison avec les classes abstraites Java, les interfaces Java sont lentes car elles nécessitent un indirection supplémentaire.
Le point principal est que:
- Le résumé est orienté objet . Il offre les données de base qu'un "objet" devrait avoir et/ou des fonctions qu'il devrait être capable de faire. Il concerne les caractéristiques de base de l'objet: ce qu'il a et ce qu'il peut faire. Les objets qui héritent de la même classe abstraite partagent donc les caractéristiques de base (généralisation).
- L'interface est orientée fonctionnalité . Il définit les fonctionnalités qu'un objet devrait avoir. Peu importe de quel objet il s'agit, tant qu'il peut faire ces fonctionnalités, qui sont définies dans l'interface, ça va. Il ignore tout le reste. Un objet/une classe peut contenir plusieurs (groupes de) fonctionnalités. il est donc possible pour une classe d'implémenter plusieurs interfaces.
Je construis un immeuble de 300 étages
Le plan du bâtiment interface
- Par exemple, Servlet (I)
Bâtiment construit sur 200 étages - partiellement terminé --- résumé
- Implémentation partielle, par exemple, servlet générique et HTTP
Construction du bâtiment terminée - béton
- Mise en œuvre complète, par exemple, propre servlet
Interface
- Nous ne savons rien de la mise en œuvre, juste des exigences. Nous pouvons Aller pour une interface.
- Chaque méthode est publique et abstraite par défaut
- C'est une classe abstraite pure à 100%
- Si nous déclarons public, nous ne pouvons pas déclarer privé et protégé
- Si nous déclarons abstrait, nous ne pouvons pas déclarer final, statique, synchronisé, strictfp et natif
- Chaque interface a publique, statique et finale
- La sérialisation et transitoire n'est pas applicable, car nous ne pouvons pas créer d'instance pour dans l'interface
- Non volatile car c'est définitif
- Chaque variable est statique
- Lorsque nous déclarons une variable dans une interface, nous devons initialiser les variables en déclarant
- Instance et bloc statique non autorisés
Abstrait
- Mise en œuvre partielle
- Il a une méthode abstraite. Un ajout, il utilise du béton
- Aucune restriction pour les modificateurs de méthode de classe abstraite
- Aucune restriction pour les modificateurs de variable de classe abstraite
- Nous ne pouvons pas déclarer d'autres modificateurs sauf abstract
- Aucune restriction pour initialiser les variables
Tiré du site Web DurgaJobs
Lorsque vous souhaitez fournir un comportement polymorphe dans une hiérarchie d'héritage, utilisez des classes abstraites.
Si vous souhaitez un comportement polymorphe pour des classes totalement non liées, utilisez une interface.
Travaillons encore sur cette question:
La première chose à vous faire savoir est que 1/1 et 1 * 1 ont le même résultat, mais cela ne signifie pas que multiplication et division sont identiques. De toute évidence, ils entretiennent de bonnes relations, mais attention, vous êtes tous les deux différents.
Je soulignerai les principales différences, et le reste a déjà été expliqué:
Les classes abstraites sont utiles pour modéliser une hiérarchie de classes. À première vue, nous savons en partie ce que exactement doit être construit, mais nous savons que construire. Et vos classes abstraites sont donc vos classes de base.
Les interfaces sont utiles pour permettre aux autres hiérarchies ou classes de savoir ce que je suis capable de faire. Et quand vous dites que je suis capable de quelque chose, vous devez avoir cette capacité. Les interfaces indiqueront qu'il est obligatoire pour une classe d'implémenter les mêmes fonctionnalités.
C'est assez simple en fait.
Vous pouvez imaginer une interface comme une classe dans laquelle il est uniquement autorisé d’avoir des méthodes abstraites et rien d’autre.
Ainsi, une interface ne peut que "déclarer" et non définir le comportement souhaité par la classe.
Une classe abstraite vous permet à la fois de déclarer (à l'aide de méthodes abstraites) et de définir (à l'aide d'implémentations complètes de méthodes) le comportement souhaité par la classe.
Et une classe normale ne vous permet que de définir, et non de déclarer, le comportement/les actions que vous voulez que la classe ait.
Une dernière chose,
En Java, vous pouvez implémenter plusieurs interfaces, mais vous ne pouvez en étendre qu'une (Classe abstraite ou Classe) ...
Cela signifie que l'héritage du comportement défini est limité à un seul par classe ... C'est-à-dire que si vous voulez une classe qui encapsule le comportement des classes A, B et C, vous devez effectuer les opérations suivantes: Classe A étend B, Classe C s'étend A .. c'est un peu comme un moyen d'avoir plusieurs héritages ...
Les interfaces d’autre part, vous pourriez simplement le faire: l’interface C implémente A, B
Donc, dans les faits, Java ne prend en charge l'héritage multiple que dans le "comportement déclaré", c'est-à-dire les interfaces, et l'héritage unique avec le comportement défini.
Espérons que cela a du sens.
La comparaison entre interface et classe abstraite est fausse. Il devrait y avoir deux autres comparaisons: 1) interface vs classe et 2) résumé vs classe finale .
Interface vs classe
Interface est un contrat entre deux objets. Par exemple, je suis un facteur et vous êtes un paquet à livrer. Je m'attends à ce que vous connaissiez votre adresse de livraison. Quand quelqu'un me donne un colis, il doit connaître son adresse de livraison:
interface Package {
String address();
}
Classe est un groupe d'objets qui obéissent au contrat. Par exemple, je suis une boîte du groupe "Boîte" et j'obéis au contrat requis par le facteur. En même temps, j'obéis à d'autres contrats:
class Box implements Package, Property {
@Override
String address() {
return "5th Street, New York, NY";
}
@Override
Human owner() {
// this method is part of another contract
}
}
Résumé vs finale
Classe abstraite est un groupe d'objets incomplets. Ils ne peuvent pas être utilisés, car il leur manque des pièces. Par exemple, je suis une boîte abstraite sensible au GPS - je sais comment vérifier ma position sur la carte:
abstract class GpsBox implements Package {
@Override
public abstract String address();
protected Coordinates whereAmI() {
// connect to GPS and return my current position
}
}
Cette classe, si héritée/étendue par une autre classe, peut être très utile. Mais par lui-même - il est inutile, car il ne peut pas avoir d'objets. Les classes abstraites peuvent être des éléments constitutifs des classes finales.
Classe finale est un groupe d'objets complets pouvant être utilisés mais non modifiables. Ils savent exactement comment travailler et quoi faire. Par exemple, je suis une boîte qui va toujours à l'adresse spécifiée lors de sa construction:
final class DirectBox implements Package {
private final String to;
public DirectBox(String addr) {
this.to = addr;
}
@Override
public String address() {
return this.to;
}
}
Dans la plupart des langages, comme Java ou C++, il est possible d'avoir juste une classe , ni abstraite ni finale. Une telle classe peut être héritée et peut être instanciée. Je ne pense pas que cela soit strictement conforme au paradigme orienté objet.
Encore une fois, comparer des interfaces avec des classes abstraites n’est pas correct.
En bref, les différences sont les suivantes:
Différences syntaxiques entre Interface et Classe abstraite :
- Les méthodes et les membres d'une classe abstraite peuvent avoir n'importe quelle visibilité. Toutes les méthodes d'une interface doivent être public . // n'est plus valable depuis Java 9
- Une classe enfant concrète d'un Abstract Class doit définir toutes les méthodes abstraites. Une classe Abstract child peut avoir des méthodes abstraites. Une interface interface qui étend une autre interface n'a pas besoin de fournir une implémentation par défaut pour les méthodes héritées de l'interface parent.
- Une classe enfant ne peut étendre qu'une seule classe. Une interface peut étendre plusieurs interfaces. Une classe peut implémenter plusieurs interfaces.
- Une classe enfant peut définir des méthodes abstraites avec une visibilité identique ou moins restrictive, tandis qu'une classe implémentant une interface doit définir toutes les méthodes d'interface comme publiques.
- Les classes abstraites peuvent avoir des constructeurs mais pas des interfaces .
- Les interfaces de Java 9 ont des méthodes statiques privées.
Dans les interfaces maintenant:
public static - supportépublic abstract - pris en chargepublic default - pris en chargeprivate static - pris en chargeprivate abstract - erreur de compilationprivate default - erreur de compilationprivate - pris en charge
La seule différence est que l'on peut participer à plusieurs héritages et que d'autres ne peuvent pas.
La définition d'une interface a évolué au fil du temps. Pensez-vous qu'une interface ne comporte que des déclarations de méthodes et ne sont que des contrats? Qu'en est-il des variables finales statiques et des définitions par défaut après Java 8?
Les interfaces ont été introduites dans Java en raison de le problème des diamants avec héritage multiple et c’est ce qu’elles comptent réellement faire.
Les interfaces sont les structures créées pour résoudre le problème de l'héritage multiple et peuvent avoir des méthodes abstraites, des définitions par défaut et des variables finales statiques.
Interface: tournez (tournez à gauche, tournez à droite.)
Classe abstraite: Roue.
Classe: Volant, dérive de Wheel, expose Interface Turn
La première consiste à catégoriser les comportements pouvant être proposés dans une grande variété de domaines, l’autre à la modélisation d’une ontologie.
Si vous avez des méthodes communes qui peuvent être utilisées par plusieurs classes, choisissez des classes abstraites. Sinon, si vous voulez que les classes suivent un plan précis, optez pour des interfaces.
Les exemples suivants le démontrent.
Classe abstraite en Java:
abstract class animals
{
// They all love to eat. So let's implement them for everybody
void eat()
{
System.out.println("Eating...");
}
// The make different sounds. They will provide their own implementation.
abstract void sound();
}
class dog extends animals
{
void sound()
{
System.out.println("Woof Woof");
}
}
class cat extends animals
{
void sound()
{
System.out.println("Meoww");
}
}
Voici une implémentation de l'interface en Java:
interface Shape
{
void display();
double area();
}
class Rectangle implements Shape
{
int length, width;
Rectangle(int length, int width)
{
this.length = length;
this.width = width;
}
@Override
public void display()
{
System.out.println("****\n* *\n* *\n****");
}
@Override
public double area()
{
return (double)(length*width);
}
}
class Circle implements Shape
{
double pi = 3.14;
int radius;
Circle(int radius)
{
this.radius = radius;
}
@Override
public void display()
{
System.out.println("O"); // :P
}
@Override
public double area()
{
return (double)((pi*radius*radius)/2);
}
}
Quelques points clés importants en un mot:
Les variables déclarées dans l'interface Java sont par défaut définitives. Les classes abstraites peuvent avoir des variables non finales.
Les variables déclarées dans l'interface Java sont par défaut statiques. Les classes abstraites peuvent avoir des variables non statiques.
Les membres d'une interface Java sont publics par défaut. Une classe abstraite Java peut avoir les saveurs habituelles des membres de classe comme privée, protégée, etc.
Pas vraiment la réponse à la question initiale, mais une fois que vous avez la réponse à la différence, vous entrerez le dilemme de chaque utilisation: Quand utiliser des interfaces ou des classes abstraites? Quand utiliser les deux?
J'ai une connaissance limitée de la programmation orientée objet, mais voir les interfaces comme l'équivalent d'un adjectif en grammaire a fonctionné jusqu'à présent pour moi (corrigez-moi si cette méthode est fausse!). Par exemple, les noms d'interface sont comme des attributs ou des capacités que vous pouvez attribuer à une classe et une classe peut en avoir plusieurs: ISerializable, ICountable, IList, ICacheable, IHappy, ...
L'héritage est utilisé à deux fins:
Permettre à un objet de considérer les membres de données de type parent et les implémentations de méthodes comme ses propres.
Pour permettre à une référence à un objet d'un type d'être utilisée par un code qui attend une référence à un objet de type supertype.
Dans les langages/frameworks qui supportent l'héritage multiple généralisé, il est souvent inutile de classer un type comme étant une "interface" ou une "classe abstraite". Les langages et les frameworks populaires permettent toutefois à un type de considérer les membres de données d'un autre type ou les implémentations de méthodes comme siens, même s'ils permettent à un type d'être substituable à un nombre arbitraire d'autres types.
Les classes abstraites peuvent avoir des membres de données et des implémentations de méthodes, mais ne peuvent être héritées que par des classes qui n'héritent d'aucune autre classe. Les interfaces n'imposent pratiquement aucune restriction quant aux types qui les implémentent, mais ne peuvent inclure aucun membre de données ni implémentation de méthode.
Il est parfois utile que les types soient substituables à beaucoup de choses différentes; il est parfois utile que les objets considèrent les membres de données de type parent et les implémentations de méthodes comme leurs propres. Faire une distinction entre les interfaces et les classes abstraites permet à chacune de ces capacités d’être utilisées dans les cas les plus pertinents.
Points clés:
- La classe abstraite peut avoir à la fois une propriété, des champs de données et des méthodes (complete /incomplete).
- Si méthode ou Propriétés définissent un mot-clé abstrait à substituer à une classe dérivée (fonction en tant que fonctionnalité étroitement couplée )
- Si vous définissez un mot-clé abstrait pour une méthode ou des propriétés dans une classe abstraite, vous ne pouvez pas définir le corps de la méthode et obtenir/définir la valeur pourproperties et que vous devez remplacer dans la classe dérivée.
- La classe abstraite ne prend pas en charge l'héritage multiple.
- La classe abstraite contient des constructeurs.
- Une classe abstraite peut contenir des modificateurs d'accès pour les sous-fonctions, fonctions et propriétés.
- Seul le membre complet de la classe abstraite peut être statique.
- Une interface peut hériter d'une autre interface uniquement et ne peut pas hériter d'une classe abstraite, une classe abstraite pouvant hériter d'une autre classe abstraite ou d'une autre interface.
Avantage:
- C'est une sorte de contrat qui oblige toutes les sous-classes à appliquer les mêmes hiérarchies ou normes.
- 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.
- 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.
- Cela permet une exécution plus rapide que l’interface (l’interface nécessite plus de temps pour trouver la méthode dans les classes correspondantes).
- Il peut utiliser pour un couplage serré et lâche.
trouver des détails ici ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/
Vous pouvez trouver une différence claire entre interface et classe abstraite.
Interface
- L'interface ne contient que des méthodes abstraites.
- Forcer les utilisateurs à implémenter toutes les méthodes lors de l'implémentation de l'interface.
- Ne contient que des variables finales et statiques.
- Déclarez à l'aide du mot clé interface.
- Toutes les méthodes d'une interface doivent être définies comme publiques.
- Une interface peut être étendue ou une classe peut implémenter plusieurs autres interfaces
Classe abstraite
La classe abstraite contient des méthodes abstraites et non abstraites.
Ne force pas les utilisateurs à implémenter toutes les méthodes lorsqu'ils héritent de la classe abstraite
Contient toutes sortes de variables, y compris primitives et non primitives
Déclarez à l'aide d'un mot clé abstrait.
Les méthodes et les membres d'une classe abstraite peuvent être définis avec n'importe quelle visibilité
Une classe enfant ne peut étendre qu'une seule classe (abstraite ou concrète).
Le moyen le plus rapide de résumer est qu'une interface est:
- Complètement abstraite, en dehors des méthodes
defaultetstatic; alors qu'il a des définitions (signatures de méthodes + implémentations) pour les méthodesdefaultetstatic, il n'a que des déclarations (signatures de méthodes) pour les autres méthodes. - Soumis à des règles plus laxistes que les classes (une classe peut implémenter plusieurs
interfaces et uninterfacepeut hériter de plusieursinterfaces). Toutes les variables sont implicitement constantes, qu'elles soient spécifiées en tant quepublic static finalou non. Tous les membres sont implicitementpublic, qu'ils soient spécifiés comme tels ou non. - Généralement utilisé pour garantir que la classe d'implémentation aura les fonctionnalités spécifiées et/ou sera compatible avec toute autre classe implémentant la même interface.
Pendant ce temps, une classe abstract est:
- De l'abstraction complète à l'implémentation complète, avec généralement une ou plusieurs méthodes
abstract. Peut contenir à la fois des déclarations et des définitions, les déclarations étant marquéesabstract. - Une classe à part entière, et soumise aux règles qui régissent les autres classes (ne peut hériter que d'une classe), à condition qu'elle ne puisse pas être instanciée (car rien ne garantit qu'elle est complètement implémentée). Peut avoir des variables de membre non constantes. Peut implémenter le contrôle d'accès des membres, en limitant les membres en tant que
protected,privateou paquet privé (non spécifié). - Généralement utilisé pour fournir autant d'implémentation que plusieurs sous-classes peuvent partager, ou pour fournir autant d'implémentation que le programmeur est en mesure de fournir.
Ou, si nous voulons tout résumer en une seule phrase: Une interface est ce que la classe d'implémentation a , mais une classe abstract est ce que la sous-classe est .
Différences entre classe abstraite et interface pour le compte d'une implémentation réelle.
Interface : C'est un mot clé qui sert à définir le modèle ou l'empreinte bleue d'un objet et oblige toutes les sous-classes à suivre le même prototype. En ce qui concerne l'implémentation, toutes les sous-classes sont libres d'implémenter. la fonctionnalité selon ses besoins.
Quelques autres cas d'utilisation où nous devrions utiliser l'interface.
La communication entre deux objets externes (intégration de tiers dans notre application) effectuée via Interface here Interface fonctionne comme un contrat.
Classe abstraite: Résumé, il s'agit d'un mot clé. Lorsque nous utilisons ce mot clé avant toute classe, il devient alors une classe abstraite. Il est principalement utilisé lorsque nous devons définir le modèle ainsi que certaines fonctionnalités par défaut d'un objet suivi de toutes les sous-classes et de cette façon il supprime le code redondant et encore un cas d'utilisation où nous pouvons utiliser une classe abstraite , comme nous voulons qu'aucune autre classe ne puisse instancier directement un objet de la classe, seules les classes dérivées peuvent utiliser la fonctionnalité.
Exemple de classe abstraite:
public abstract class DesireCar
{
//It is an abstract method that defines the prototype.
public abstract void Color();
// It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.
// and hence no need to define this in all the sub classes in this way it saves the code duplicasy
public void Wheel() {
Console.WriteLine("Car has four wheel");
}
}
**Here is the sub classes:**
public class DesireCar1 : DesireCar
{
public override void Color()
{
Console.WriteLine("This is a red color Desire car");
}
}
public class DesireCar2 : DesireCar
{
public override void Color()
{
Console.WriteLine("This is a red white Desire car");
}
}
Exemple d'interface:
public interface IShape
{
// Defines the prototype(template)
void Draw();
}
// All the sub classes follow the same template but implementation can be different.
public class Circle : IShape
{
public void Draw()
{
Console.WriteLine("This is a Circle");
}
}
public class Rectangle : IShape
{
public void Draw()
{
Console.WriteLine("This is a Rectangle");
}
}
Pour donner une réponse simple mais claire, il est utile de définir le contexte: vous utilisez les deux lorsque vous ne souhaitez pas fournir d’implémentations complètes.
La principale différence est alors qu’une interface n’a aucune implémentation (seulement des méthodes sans corps) alors que les classes abstraites peuvent avoir des membres et que des méthodes avec un corps aussi, c’est-à-dire qu’elles peuvent être partiellement implémentées.
Je voudrais ajouter une autre différence qui a du sens… .. Par exemple, vous avez un framework avec des milliers de lignes de code. Maintenant, si vous souhaitez ajouter une nouvelle fonctionnalité dans le code à l'aide d'une méthode enhanUI (), il est préférable d'ajouter cette méthode plutôt dans une classe abstraite que dans une interface. En effet, si vous ajoutez cette méthode dans une interface, vous devez l'implémenter dans toutes les classes implémentées, mais ce n'est pas le cas si vous ajoutez la méthode dans une classe abstraite.
Par définition, les interfaces ne peuvent avoir d’implémentation pour aucune méthode et les variables membres ne peuvent pas être initialisées.
Cependant, les classes abstraites peuvent avoir des méthodes implémentées et des variables membres initialisées.
Utilisez des classes abstraites lorsque vous prévoyez des modifications dans votre contrat, c’est-à-dire qu’il vous faudra peut-être ajouter une nouvelle méthode.
Dans cette situation, si vous décidez d'utiliser une interface, lorsque cette dernière sera modifiée pour inclure l'interface, votre application sera interrompue lorsque vous dumperez la nouvelle dll d'interface.
Pour lire en détail, visitez différence entre une classe abstraite et une interface
Une classe abstraite est une classe dont l'objet ne peut pas être créé ou une classe qui ne peut pas être instanciée ..__ Une méthode abstraite rend une classe abstraite. Une classe abstraite doit être héritée afin de remplacer les méthodes déclarées dans la classe abstraite. Aucune restriction sur les spécificateurs d'accès. Une classe abstraite peut contenir un constructeur et d’autres méthodes concrètes (méthodes non abstarct), mais pas une interface.
Une interface est un plan/modèle de méthodes (par exemple, une maison sur un papier est donnée (interface maison) et différents architectes utiliseront leurs idées pour la construire (les classes d'architectes mettant en œuvre l'interface maison). une collection de méthodes abstraites, méthodes par défaut, méthodes statiques, variables finales et classes imbriquées . Tous les membres seront des spécificateurs d'accès final ou public, protégé et privé ne sont pas autorisés. Aucune création d'objet n'est autorisée. Une classe Pour utiliser l'interface d'implémentation et remplacer la méthode abstraite déclarée dans l'interface, une interface est un bon exemple de couplage lâche (polymorphisme dynamique/liaison dynamique) Une interface implémente le polymorphisme et l'abstraction.It indique ce qu'il faut faire, mais la manière de le faire est définie par la classe d'implémentation. Par exemple, il existe un constructeur automobile qui souhaite que certaines fonctionnalités soient identiques pour toutes les voitures fabriquées de cette manière. véhicule d'interface ch aura ces caractéristiques et différentes classes de voiture (comme Maruti Suzkhi, Maruti 800) remplaceront ces caractéristiques (fonctions).
Pourquoi une interface alors que nous avons déjà une classe abstraite? Java ne prend en charge que l'héritage multiniveau et hiérarchique, mais avec l'aide de l'interface, nous pouvons implémenter l'héritage multiple.
Une explication simple mais efficace de la classe abstraite et de l'interface sur php.net :
Une interface est comme un protocole. Cela ne désigne pas le comportement de l'objet; il indique comment votre code dit à cet objet d'agir. Une interface ressemblerait à la langue anglaise: définir une interface définit la manière dont votre code communique avec tout objet implémentant cette interface.
Une interface est toujours un accord ou une promesse. Quand une classe dit "j'implémente l'interface Y", elle dit "je promets d'avoir les mêmes méthodes publiques que n'importe quel objet avec l'interface Y".
D'autre part, une classe abstraite est comme une classe partiellement construite. Cela ressemble beaucoup à un document avec des blancs à remplir. Il utilise peut-être l'anglais, mais ce n'est pas aussi important que le fait que certains documents sont déjà écrits.
Une classe abstraite est la base d'un autre objet. Quand une classe dit "J'étend la classe abstraite Y", elle dit "J'utilise des méthodes ou des propriétés déjà définies dans cette autre classe appelée Y".
Alors, considérons le PHP suivant:
<?php class X implements Y { } // this is saying that "X" agrees to speak language "Y" with your code. class X extends Y { } // this is saying that "X" is going to complete the partial class "Y". ?>Vous voudriez que votre classe implémente une interface particulière si vous distribuiez une classe qui serait utilisée par d'autres personnes. L'interface est un accord pour avoir un ensemble spécifique de méthodes publiques pour votre classe.
Vous voudriez que votre classe étende une classe abstraite si vous (ou quelqu'un d'autre) avez écrit une classe dans laquelle certaines méthodes ont déjà été écrites que vous souhaitez utiliser dans votre nouvelle classe.
Ces concepts, bien que faciles à confondre, sont spécifiquement différents et distincts. À toutes fins utiles, si vous êtes le seul utilisateur de l'une de vos classes, vous n'avez pas besoin de mettre en œuvre des interfaces.
Dans une interface, toutes les méthodes doivent être uniquement des définitions, pas une seule ne doit être implémentée.
Mais dans une classe abstraite, il faut une méthode abstraite avec seulement définition, mais d'autres méthodes peuvent aussi être dans la classe abstraite avec implémentation ...
Voici une compréhension très élémentaire de l'interface vs classe abstraite.
généralement classe abstraite utilisée pour le noyau de quelque chose mais interface utilisée pour ajouter un périphérique.
lorsque vous souhaitez créer un type de base pour un véhicule, vous devez utiliser une classe abstraite, mais si vous souhaitez ajouter des fonctionnalités ou des propriétés ne faisant pas partie du concept de base du véhicule, vous devez utiliser une interface, par exemple, vous souhaitez ajouter la fonction "ToJSON ()". .
l’interface a un large éventail d’abstractions plutôt que de la classe abstraite . Vous pouvez le voir en passant des arguments. Regardez cet exemple:
si vous utilisez véhicule comme argument, vous pouvez simplement utiliser l'un de ses types dérivés (bus ou voiture - même catégorie - seulement catégorie de véhicule) ., mais lorsque vous utilisez l'interface IMoveable comme argument, vous avez davantage de choix.
Les interfaces sont généralement les classes sans logique, juste une signature. Alors que les classes abstraites sont celles qui ont une logique. Les deux contrats de support en tant qu'interface, toutes les méthodes doivent être implémentées dans la classe enfant mais, dans l'abstrait, seule la méthode abstraite doit être implémentée. Quand utiliser l'interface et quand résumer? Pourquoi utiliser l'interface?
class Circle {
protected $radius;
public function __construct($radius)
{
$this->radius = $radius
}
public function area()
{
return 3.14159 * pow(2,$this->radius); // simply pie.r2 (square);
}
}
//Our area calculator class would look like
class Areacalculator {
$protected $circle;
public function __construct(Circle $circle)
{
$this->circle = $circle;
}
public function areaCalculate()
{
return $circle->area(); //returns the circle area now
}
}
Nous ferions simplement
$areacalculator = new Areacalculator(new Circle(7));
Quelques jours plus tard, nous aurions besoin du rectangle, du carré, du quadrilatère, etc. Si c'est le cas, devons-nous changer le code à chaque fois et vérifier si l'instance est un carré, un cercle ou un rectangle? Maintenant, ce que dit OCP, CODE TO IN INTERFACE N'EST PAS UNE MISE EN ŒUVRE. La solution serait:
Interface Shape {
public function area(); //Defining contract for the classes
}
Class Square implements Shape {
$protected length;
public function __construct($length) {
//settter for length like we did on circle class
}
public function area()
{
//return l square for area of square
}
Class Rectangle implements Shape {
$protected length;
$protected breath;
public function __construct($length,$breath) {
//settter for length, breath like we did on circle,square class
}
public function area()
{
//return l*b for area of rectangle
}
}
Maintenant pour le calculateur de surface
class Areacalculator {
$protected $shape;
public function __construct(Shape $shape)
{
$this->shape = $shape;
}
public function areaCalculate()
{
return $shape->area(); //returns the circle area now
}
}
$areacalculator = new Areacalculator(new Square(1));
$areacalculator->areaCalculate();
$areacalculator = new Areacalculator(new Rectangle(1,2));
$areacalculator->;areaCalculate();
N'est-ce pas plus flexible? Si nous codions sans interface, nous vérifions l'instance pour chaque code redondant de forme.
Maintenant, quand utiliser abstract?
Abstract Animal {
public function breathe(){
//all animals breathe inhaling o2 and exhaling co2
}
public function hungry() {
//every animals do feel hungry
}
abstract function communicate();
// different communication style some bark, some meow, human talks etc
}
Maintenant, abstract devrait être utilisé quand on n'a pas besoin d'instance de cette classe, ayant une logique similaire, ayant besoin du contrat.
L'idée générale des classes abstraites et des iterfaces doit être étendue/implémentée par d'autres classes (ne pouvant pas être construites seules) qui utilisent ces "paramètres" généraux (une sorte de modèle), facilitant ainsi la définition d'un comportement spécifique-général pour tous. les objets qui l'étendent plus tard.
Une classe abstraite a un ensemble de méthodes régulières ET des méthodes abstraites. Les classes étendues peuvent inclure des méthodes non définies après avoir été étendues par une classe abstraite. Lors de la définition de méthodes abstraites, elles sont définies par les classes qui l'étendent ultérieurement.
Les interfaces ont les mêmes propriétés qu'une classe abstraite, mais n'incluent que des méthodes abstraites, qui pourraient être implémentées dans une autre classe/es (et peuvent être plus d'une interface à implémenter), cela crée une définition plus permanente/solide des méthodes/statique variables. Contrairement à la classe abstraite, vous ne pouvez pas ajouter de méthodes "standard" personnalisées.
En termes pratiques (Java), la principale différence entre la classe abstraite et l'interface est La classe abstraite peut conserver un état. Outre l'état de conservation, nous pouvons également effectuer des opérations de repos avec Interface.
Nous avons différentes différences structurelles/syntaxiques entre interface et classe abstraite. Quelques autres différences sont
[1] Différence basée sur un scénario :
Les classes abstraites sont utilisées dans des scénarios lorsque nous souhaitons limiter l'utilisateur à la création d'un objet de classe parent ET nous pensons que d'autres méthodes abstraites seront ajoutées à l'avenir.
L'interface doit être utilisée quand nous sommes sûrs qu'il ne peut plus y avoir de méthode abstraite à fournir. Ensuite, seule une interface est publiée.
[2] Différence conceptuelle :
"Avons-nous besoin de fournir plus de méthodes abstraites à l'avenir" si OUI en fait une classe abstraite et si NON en fait une interface.
(Le plus approprié et valide jusqu'au Java 1.7)