Quelle est la différence entre une interface et une classe abstraite?

Quelle est exactement la différence entre une interface et une classe abstraite?

1518
demandé sur brice 2009-12-16 11:15:15
la source

30 ответов

Interfaces

une interface est un contrat : la personne qui écrit l'interface dit, " Hé, j'accepte les choses qui regardent de cette façon ", et la personne qui utilise l'interface dit " OK, la classe que j'écris regarde de cette façon ".

une interface est un shell vide . Il y a seulement les signatures des méthodes, ce qui implique que les méthodes n'ont pas de corps. L'interface ne peut pas faire n'importe quoi. C'est juste un modèle.

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;
    }
}

implémenter une interface consomme très peu de CPU, parce que ce n'est pas une classe, juste un tas de noms, et donc il n'y a pas de recherche coûteuse à faire. C'est génial quand c'est important, comme dans les appareils intégrés.


classes abstraites

classes abstraites, contrairement interfaces, sont des classes. Ils sont plus chers à utiliser, parce qu'il ya un look-up à faire lorsque vous héritez d'eux.

les classes abstraites ressemblent beaucoup à des 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 cours devraient ressembler à ça, et ils ont ça 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 œuvre

alors que les classes abstraites et les interfaces sont supposées être des concepts différents, les implémentations rendent cette affirmation parfois fausse. Parfois, ils sont même pas ce que vous pensez qu'ils sont.

en Java, cette règle est fortement imposée, alors qu'en PHP, les interfaces sont des classes abstraites sans méthode déclarée.

en Python, les classes abstraites sont plus un truc de programmation que vous pouvez obtenir à partir du module ABC et est en fait en utilisant des métaclasses, et donc des classes. Et les interfaces sont plus liées à duck typing dans ce langage et c'est un mélange entre des conventions et des méthodes spéciales qui appellent des descripteurs (les méthodes ___ method__).

comme d'habitude avec la programmation, il y a la théorie, la pratique et la pratique dans une autre langue :-)

2002
répondu e-satis 2018-05-16 05:56:36
la source

les principales différences techniques entre une classe abstraite et une interface sont:

  • les classes abstraites peuvent avoir les constantes, les membres, les bâtonnets de méthode (méthodes sans corps) et les méthodes définies , tandis que les interfaces peuvent seulement avoir les constantes et les bâtonnets de méthode .

  • méthodes et membres d'une classe abstraite peuvent être définis avec toute visibilité , alors que toutes les méthodes d'une interface doivent être définies comme public (ils sont définis public par défaut).

  • lorsqu'elle hérite d'une classe abstraite, une concrète classe enfant doit définir les méthodes abstraites , alors qu'une classe abstraite peut étendre une autre classe abstraite et abstraite. les méthodes de la classe parent n'ont pas à être définis.

  • de même, une interface étendant une autre interface est Non responsable de la mise en œuvre des méthodes à partir de l'interface mère. C'est parce que les interfaces ne peuvent définir aucune implémentation.

  • une classe d'enfants ne peut que étendre une seule classe (abstrait ou béton), alors qu'une interface peut de prolonger ou d'une classe peut mettre en œuvre plusieurs autres interfaces .

  • une classe enfant peut définir des méthodes abstraites avec la visibilité identique ou moins restrictive , alors qu'une classe implémentant une interface doit définir les méthodes avec la même visibilité exacte (publique).

777
répondu Justin Johnson 2016-11-20 17:14:29
la source

une Interface ne contient que la définition / signature de la fonctionnalité, et si nous avons une fonctionnalité commune ainsi que des signatures communes, alors nous devons utiliser une classe abstraite. En utilisant une classe abstraite, nous pouvons fournir le comportement ainsi que la fonctionnalité à la fois dans le même temps. Un autre développeur héritant de la classe abstract peut utiliser cette fonctionnalité facilement, car ils n'auraient besoin que de remplir les blancs.

enter image description here

tiré 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.html http://www.dotnetbull.com/2011/11/what-is-interface-in-c-net.html

115
répondu Vivek 2016-06-30 20:42:28
la source

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 mise en œuvre partielle seulement par le programmeur. Il peut contenir un ou plusieurs des 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 appliquée chez un enfant classe.

une interface est similaire à un résumé classe; en effet, les interfaces occupent même namespace que classes et abstrait classe. 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; aucun de ses méthodes sont mis en œuvre et au lieu d'une classe sous-classement, il est dit implémentez cette interface.

quoi qu'il en soit je trouve ceci explication des interfaces quelque peu confuse. Une définition plus courante est: une interface définit un contrat que la mise en œuvre des classes doit remplir. Une définition d'interface se compose de signatures de membres publics, sans aucun code de mise en œuvre.

77
répondu Konamiman 2009-12-16 11:24:10
la source

quelques différences importantes:

sous forme de tableau:

Difference

Comme , a déclaré 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 Java abstract 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 finales. Une classe abstraite peut contenir des variables non finales.

3.Les membres d'une interface Java sont publics par défaut. Une classe Java abstract peut avoir les saveurs habituelles des membres de classe comme privé, protégées, etc..

4.L'interface Java doit être implémentée en utilisant le mot-clé "implements"; une classe de résumé Java doit être étendue en utilisant le mot-clé "extends".

5.Une interface peut étendre une autre interface Java seulement, une classe abstraite peut étendre une autre classe Java et mettre en œuvre plusieurs Java interface.

6.Une classe Java peut implémenter plusieurs interfaces, mais elle ne peut étendre qu'une seule classe abstraite.

7.L'Interface est absolument abstraite et ne peut pas être instanciée; une classe abstraite Java ne peut pas non plus être instanciée, mais peut être invoquée si main() existe.

8.En comparaison avec les classes de Java abstract, les interfaces java sont lentes car elles nécessitent des actions indirectes supplémentaires.

37
répondu softmage99 2013-10-14 23:53:02
la source

Je ne veux pas mettre en évidence 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 soutien pour les méthodes protégées, privées dans les classes abstraites)

En termes simples, je voudrais dire:

interface: pour mettre en œuvre un contrat par plusieurs objets indépendants

classe abstraite: mettre en œuvre le même comportement ou un comportement différent parmi plusieurs objets connexes

de L'Oracle documentation

envisager l'utilisation des classes abstraites si:

  1. vous voulez partager le code entre plusieurs classes étroitement liées.
  2. vous vous attendez à ce que les classes qui étendent votre classe abstraite aient beaucoup de méthodes ou de champs communs, ou exigent l'accès modificateurs autres que publics (tels que protégés et privés).
  3. vous voulez déclarer les champs non-statiques ou non-finaux.

envisager l'utilisation d'interfaces si:

  1. vous vous attendez à ce que des classes indépendantes implémentent votre interface. Par exemple, de nombreux objets indépendants peuvent implémenter l'interface Serializable .
  2. Vous souhaitez spécifier le comportement d'un type de données particulier, mais ne se préoccupe pas de savoir qui met en œuvre son comportement.
  3. Vous voulez profiter de l'héritage multiple de type.

classe abstraite établit "est une" relation avec les classes de béton. interface fournit "a une" capacité pour les classes.

si vous recherchez Java comme langage de programmation, voici quelques mises à jour supplémentaires:

Java 8 a réduit l'écart entre les classes interface et abstract dans une certaine mesure en fournissant une caractéristique de méthode default . une interface n'a pas d'implémentation pour une méthode n'est plus valide maintenant.

référez-vous à cette documentation page pour plus de détails.

regardez cette question pour des exemples de code pour mieux comprendre.

Comment aurais-je dû expliquer la différence entre une Interface et une classe abstraite?

35
répondu Ravindra babu 2017-05-23 15:34:53
la source

Le point principal est que:

  • Abstrait est orienté objet . Il offre les données de base qu'un 'objet' devrait avoir et/ou les fonctions qu'il devrait être capable de faire. Il est concerné par l'objet, les caractéristiques de base: ce qu'il a et ce qu'il peut faire. Donc des objets qui héritent de la même classe abstraite partager les caractéristiques de base (généralisation).
  • Interface orientée fonctionnalité . Il définit les fonctionnalités qu'un objet devrait avoir. Peu importe quel objet il est, tant qu'il peut faire ces fonctionnalités, qui sont définies dans l'interface, il est très bien. Il ignore tout le reste. Un objet / classe peut contenir plusieurs (groupes de) fonctionnalités; il est donc possible pour une classe d'implémenter plusieurs interfaces.
25
répondu Yusup 2016-06-30 20:48:12
la source

si vous voulez fournir un comportement polymorphe dans une hiérarchie héréditaire, utilisez des classes abstraites.

si vous voulez un comportement polymorphe pour des classes qui n'ont aucun rapport, utilisez une interface.

22
répondu sculptor 2016-11-20 17:21:38
la source

je construis un bâtiment de 300 étages

le plan du bâtiment interface

  • par exemple, Servlet (I)

Bâtiment construit jusqu'à 200 étages - partiellement complété--- abstrait

  • une mise en œuvre Partielle, par exemple, générique et HTTP servlet

bâtiment construction terminée - béton

  • la Pleine mise en œuvre, 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 pure à 100% de la classe abstraite
  • 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
  • Serialization and transient n'est pas applicable, car nous ne pouvons pas créer une instance pour In interface
  • Non-volatile car elle est définitive
  • chaque variable est statique
  • Lorsque nous déclarons une variable à l'intérieur d'une interface, nous devons initialiser les variables tout en déclarant
  • Instance et bloc statique non autorisés

Abstrait

  • application partielle
  • Il a une méthode abstraite. Un ajout, il utilise du béton
  • Pas de restriction pour le résumé de la méthode de classe modificateurs
  • aucune restriction pour la variable de classe abstraite modificateurs
  • nous ne pouvons pas déclarer d'autres modificateurs sauf abstrait
  • aucune restriction pour initialiser les variables

tiré du site de DurgaJobs

22
répondu Jaichander 2018-04-01 12:35:05
la source

retravaillons cette question:

la première chose à vous faire savoir est que 1/1 et 1*1 donnent les mêmes résultats, mais cela ne signifie pas que la multiplication et la division sont les mêmes. Évidemment, ils entretiennent de bonnes relations, mais vous êtes tous les deux différents.

je vais souligner les principales différences, et le reste ont déjà été expliquées:

les classes Abstraites sont utiles pour la modélisation d'une hiérarchie de classe. Au premier abord coup d'oeil de n'importe quelle exigence, nous sommes partiellement clair sur ce que exactement doit être construit, mais nous savons ce qu'il faut construire. et donc vos classes abstraites sont vos classes de base.

Les Interfaces

sont utiles pour permettre à d'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 la capacité. Interfaces sera obligatoire pour une classe pour mettre en œuvre la même fonctionnalité.

18
répondu Dhananjay 2016-11-20 17:18:24
la source

c'est assez simple en fait.

Vous pouvez penser à une interface d'une classe qui n'est permis d'avoir des méthodes abstraites et rien d'autre.

donc une interface ne peut que" déclarer " et ne pas définir le comportement que vous voulez que la classe ait.

une classe abstraite vous permet à la fois de déclarer (en utilisant des méthodes abstraites) et de définir (en utilisant des implémentations de méthodes complètes) le comportement que vous voulez que la classe ait.

et une classe régulière ne vous permet de définir, pas de déclarer, le comportement/actions que vous voulez que la classe ait.

une dernière chose,

en Java, vous pouvez implémenter plusieurs interfaces, mais vous ne pouvez étendre qu'une seule (classe abstraite ou classe)...

, Cela signifie que l'héritage de comportement défini est limité à un seul par classe... c'est-à-dire si vous vouliez une classe qui encapsulait les comportements des Classes A, B et C vous devez faire ce qui suit: Classe A étend B, Classe C étend A.. c'est un peu d'un rond-point moyen d'avoir de l'héritage multiple...

Interfaces d'autre part, vous pouvez simplement faire: interface C met en œuvre a ,b

donc en effet, Java ne supporte l'héritage multiple que dans les interfaces" comportement déclaré", c'est-à-dire l'héritage unique avec un comportement défini.. à moins que vous ne la ronde manière que j'ai décrite...

Espérons que cela a du sens.

12
répondu g00dnatur3 2017-03-18 01:31:14
la source

la comparaison entre la classe interface et la classe abstraite est fausse. Il devrait y avoir deux autres comparaisons à la place: 1) interface vs. class et 2) abstract vs. final class .

Interface vs Class

Interface est un contrat entre deux objets. Par exemple, Je suis facteur et tu es un paquet à livrer. Je vous attends pour connaître votre adresse de livraison. Quand quelqu'un me donne un Paquet, il doit connaître son adresse de livraison:

interface Package {
  String address();
}

Classe est un groupe d'objets qui obéissent le contrat. Par exemple, Je suis une boîte du groupe "Box" et j'obéis au contrat demandé 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
  }
}

Abstrait vs Finale

la classe Abstraite est un groupe d'objets incomplets. Ils ne peuvent pas être utilisés, car ils manquent certains partie. Par exemple, Je suis une case GPS abstraite-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é prolongée 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 constituer des éléments des classes finales.

Dernier de la classe est un groupe d'objets, qui peuvent être utilisés, mais ne peut pas être modifié. Ils savent exactement comment travailler et de 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 langues, comme Java ou C++, il est possible d'avoir juste une classe , ni abstrait ni final. Une telle classe peut être héritée et instanciée. Je ne pense pas que cela soit strictement conforme au paradigme orienté objet.

encore une fois, comparer les interfaces avec les classes abstraites n'est pas correct.

9
répondu yegor256 2014-07-25 01:57:49
la source

la seule différence est que l'un peut participer à l'héritage multiple et l'autre ne peut pas.

La définition d'une interface a changé au fil du temps. Pensez-vous qu'une interface n'a que des déclarations de méthode 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?

Interfaces ont été introduits à Java en raison de le problème de diamant avec héritage multiple et c'est ce qu'ils ont l'intention de faire.

Interfaces sont les constructions qui ont été créées pour s'en tirer avec le problème de l'héritage multiple et peut avoir des méthodes abstraites, des définitions par défaut et des variables finales statiques.

voir pourquoi Java autorise-t-il les variables finales statiques dans les interfaces lorsqu'elles ne sont que des contrats? .

9
répondu Vivek Vermani 2016-12-05 19:44:22
la source

en résumé, les différences sont les suivantes:

différences syntaxiques entre Interface et classe abstraite :

  1. 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 publique . //N'est pas vrai de Java 9 plus
  2. une classe enfant en béton d'une classe Abstract doit définir toutes les méthodes abstraites. Une classe Abstract child peut avoir des méthodes abstraites. Une interface extension d'une autre interface n'a pas besoin de fournir l'implémentation par défaut pour les méthodes héritées de l'interface parent.
  3. une classe d'enfants ne peut étendre qu'une seule classe. Une interface peut étendre plusieurs interface. Une classe peut implémenter plusieurs interfaces.
  4. une classe enfant peut définir des méthodes abstraites avec la même visibilité ou une visibilité moins restrictive, tandis que la classe mettant en œuvre une interface doit définir toutes les méthodes d'interface comme étant publiques.
  5. classes abstraites peuvent avoir des constructeurs mais pas interfaces .
  6. les Interfaces de Java 9 ont des interfaces statiques privées méthode.

dans Interfaces now:

public static - supported

public abstract - prise en charge

public default - prise en charge

private static - prise en charge

private abstract - erreur de compilation

private default - erreur de compilation

private - 151980920"

8
répondu Pritam Banerjee 2017-10-27 08:18:44
la source

Interface: Tourner (Tourner À Gauche, Tourner À Droite.)

Classe Abstraite: La Roue.

Classe: Volant de direction, dérive du volant, expose le virage à L'Interface

L'un est pour catégoriser le comportement qui peut être offert à travers un éventail de choses, l'autre est pour modéliser une ontologie des choses.

7
répondu Sentinel 2017-03-07 00:46:53
la source

pas vraiment la réponse à la question d'origine, mais une fois que vous avez la réponse à la différence entre eux, vous allez entrer le quand-à-l'utilisation-chaque dilemme: quand utiliser des interfaces ou des classes abstraites? Quand utiliser les deux?

j'ai une connaissance limitée de L'OOP, mais voir les interfaces comme l'équivalent d'un adjectif en grammaire a fonctionné pour moi jusqu'à présent (corrigez-moi si cette méthode est fausse!). Par exemple, interface les noms sont comme des attributs ou des capacités que vous pouvez donner à une classe, et une classe peut en avoir beaucoup: Iserialisable, ICountable, IList, ICacheable, IHappy, ...

4
répondu azkotoki 2017-05-23 15:02:57
la source

si vous avez des méthodes communes qui peuvent être utilisées par plusieurs classes, allez pour les classes abstraites. Sinon, si vous voulez que les classes suivent un plan défini, optez pour des interfaces.

les exemples suivants le démontrent.

classe Abstraite 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");
    }
}

suivant est une implémentation d'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:

  1. les variables déclarées dans L'interface Java sont par défaut finales. Les classes abstraites peuvent avoir des variables non finales.

  2. les variables déclarées dans L'interface Java sont par défaut statiques. Les classes abstraites peuvent avoir des variables non statiques.

  3. les membres D'une interface Java sont publics par défaut. Une classe Java abstract peut avoir les saveurs habituelles des membres de la classe comme privé, protégé, etc..

4
répondu Pransh Tiwari 2017-10-03 09:25:57
la source

l'Héritage est utilisé à deux fins:

  • pour permettre à un objet de considérer les membres de données de type parent et les implémentations de méthode comme les siens.

  • permettre une référence à un objet d'un type d'être utilisé par un code qui attend une référence à un objet supertype.

Dans des langues/des cadres de l'appui généralisé de l'héritage multiple, il est souvent peu de nécessité de classer un type comme étant une "interface" ou une "classe abstraite". Les langages et les cadres populaires, cependant, permettront à un type de considérer les membres de données d'un autre type ou les implémentations de méthodes comme ses propres, 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 ne mettent pratiquement aucune restriction sur les types qui les implémentent, mais ne peuvent inclure aucun membre de données ou implémentation de méthode.

il y a des moments où il est utile pour les types d'être substituables pour beaucoup de choses différentes; il y a d'autres moments où il est utile pour les objets de considérer les membres de données de type parent et les implémentations de méthode comme les leurs. Faire une distinction entre les interfaces et les classes abstraites permet d'utiliser chacune de ces capacités dans les cas où il est le plus pertinent.

3
répondu supercat 2013-09-03 20:09:55
la source

Points Clés:

  • classe Abstraite peut avoir des biens, des champs de Données ,les Méthodes (complet / incomplète) à la fois.
  • si la méthode ou les propriétés définissent dans le mot-clé abstrait qui doit primer dans la classe dérivée.(son travail comme un étroitement associée la fonctionnalité)
  • Si définir le mot clé abstract pour la méthode ou des propriétés dans la classe abstraite vous ne pouvez pas définir le corps de la méthode et obtenir/définir la valeur pour propriétés et qui doivent primer dans la classe dérivée.
  • classe Abstraite ne supporte pas l'héritage multiple.
  • classe Abstraite contient des Constructeurs.
  • Une classe abstraite peut contenir des modificateurs d'accès pour les sous-titres, fonctions, 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, où comme une classe abstraite peut hériter d'une autre classe abstraite ou une interface.

avantage:

  • il s'agit d'une sorte de contrat qui oblige toutes les sous-classes à appliquer les mêmes hiérarchies ou normes.
  • si diverses implémentations sont de même nature et utilisent un comportement ou un statut commun, alors la classe abstraite est meilleure à utiliser.
  • si nous ajoutons une nouvelle méthode à une classe abstraite alors nous avons l'option de fournir la mise en œuvre par défaut et donc tout le code existant pourrait fonctionner correctement.
  • Its permettent une exécution rapide que l'interface.(interface Requiert plus de temps pour trouver la méthode dans les classes correspondantes.)
  • il peut utiliser pour l'accouplement serré et lâche.

plus de détails ici... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops /

3
répondu Pradeep atkari 2014-12-05 13:00:14
la source

la façon la plus courte de le résumer est qu'un interface est:

  1. entièrement abstrait, à l'exception des méthodes default et static ; bien qu'il ait des définitions (signatures de méthode + implémentations) pour les méthodes default et static , il n'a que des déclarations (signatures de méthode) pour les autres méthodes.
  2. sous réserve de règles plus laxistes que les classes (une classe peut mettre en œuvre plusieurs interface s, et un interface peut hériter du multiple interface s). Toutes les variables sont implicitement constantes, qu'elles soient spécifiées par public static final ou non. Tous les membres sont implicitement public , qu'ils soient spécifiés comme tels ou non.
  3. généralement utilisé comme garantie que la classe d'implémentation aura les caractéristiques spécifiées et/ou sera compatible avec toute autre classe qui implémente la même interface.

pendant ce temps, une classe abstract est:

  1. N'importe où, de l'abstrait à la mise en œuvre complète, avec une tendance à avoir une ou plusieurs méthodes abstract . Peut contenir à la fois des déclarations et des définitions, avec des déclarations marquées comme abstract .
  2. une classe à part entière, et soumise aux règles qui régissent les autres classes (ne peut hériter que d'une seule classe), à condition qu'elle ne puisse pas être instanciée (parce qu'il n'y a aucune garantie qu'elle soit pleinement mise en œuvre). Peut avoir des non-constant variables des membres. Peut implémenter le contrôle d'accès des membres, en limitant les membres comme protected , private , ou paquet privé (non spécifié).
  3. généralement utilisé soit pour fournir autant de la mise en œuvre que peut être partagé par plusieurs sous-classes, ou pour fournir autant de la mise en œuvre que le programmeur est en mesure de fournir.

ou, si nous voulons tout ramener à une seule phrase: un interface est ce que la mise en œuvre la classe a , mais la classe abstract est ce que la sous-classe est .

3
répondu Justin Time 2016-01-29 00:58:45
la source

beaucoup de développeurs juniors font l'erreur de penser aux interfaces, aux classes abstraites et concrètes comme de légères variations de la même chose, et en choisissent une uniquement pour des raisons techniques: ai-je besoin d'un héritage multiple? Ai-je besoin d'un endroit pour mettre des méthodes communes? Dois-je m'embêter avec autre chose qu'un cours sur le béton? c'est mal, et caché dans ces questions est le problème principal: " I " . Quand vous écrivez le code pour vous, par vous-même, vous pensez rarement à d'autres développeurs présents ou futurs travaillant sur ou avec votre code.

les Interfaces et les classes abstraites, bien qu'apparemment similaires d'un point de vue technique, ont des significations et des buts complètement différents.

résumé

  1. une interface définit un contrat qu'une certaine mise en œuvre remplira pour vous .

  2. Une classe abstraite fournit un comportement par défaut que mise en œuvre peut réutiliser.

Alternative "résumé de la 1519260920"
  1. d'Une interface pour la définition des Api publiques
  2. une classe abstraite est destinée à un usage interne et à la définition des IPs

Sur l'importance de cacher les détails d'implémentation

Une classe concrète le travail réel, d'une façon très spécifique. Par exemple, un ArrayList utilise une zone contiguë de mémoire pour stocker une liste d'objets d'une manière compacte qui offre un accès aléatoire rapide, itération, et changements en place, mais est terrible à insertions, délétions, et parfois même additions; pendant ce temps, un LinkedList utilise des noeuds doubles liés pour stocker une liste d'objets, qui au lieu de cela offre itération rapide, des changements en place, et l'insertion/suppression/addition, mais est terrible à l'accès aléatoire. Ces deux types de listes sont optimisés pour différents cas d'utilisation, et cela compte beaucoup comment vous allez les utiliser. Lorsque vous essayez d'extraire une performance d'une liste avec laquelle vous interagissez fortement, et lorsque vous choisissez le type de liste qui vous convient, vous devez choisir soigneusement celle que vous instanciez.

d'autre part, les utilisateurs de haut niveau de une liste ne se soucie pas vraiment de la façon dont elle est mise en œuvre, et elle devrait être isolée de ces détails. Imaginons que Java n'ait pas exposé l'interface List , mais n'ait eu qu'une classe List concrète qui est en fait ce que LinkedList est en ce moment. Tous les développeurs Java auraient adapté leur code pour s'adapter aux détails de la mise en œuvre: éviter les accès aléatoires, ajouter un cache pour accélérer l'accès, ou tout simplement réimposer ArrayList sur leur propre, bien qu'il serait incompatible avec tous l'autre code qui fonctionne réellement avec List . Ce serait terrible... Mais maintenant, imaginez que les maîtres Java se rendent compte qu'une liste liée est terrible pour la plupart des cas d'utilisation réelle, et ont décidé de passer à une liste de tableaux pour leur seule classe List disponible. Cela affecterait la performance de chaque programme Java dans le monde, et les gens ne seraient pas heureux à ce sujet. Et le principal coupable est que les détails de la mise en œuvre étaient disponibles, et les développeurs ont supposé que ces détails sont un contrat permanent sur lequel ils peuvent compter. C'est pourquoi il est important de cacher les détails de la mise en œuvre, et de ne Définir qu'un contrat abstrait. C'est le but d'une interface: définir quel type d'entrée une méthode accepte, et quel type de sortie est attendue, sans exposer tous les tripes qui tenteraient les programmeurs de modifier leur code pour s'adapter aux détails internes qui pourraient changer avec n'importe quelle future mise à jour.

Une classe abstraite est au milieu entre interfaces et classes de béton. Il est censé aider les implémentations à partager un code commun ou ennuyeux. Par exemple, AbstractCollection fournit des implémentations de base pour isEmpty basé sur la taille est 0, contains comme itérate et comparer, addAll comme répété add , et ainsi de suite. Cela permet aux implémentations de se concentrer sur les parties cruciales qui les différencient: comment réellement stocker et récupérer des données.

APIs versus SPIs

Les Interfaces sont de faible cohésion passerelles entre différentes parties du code. Ils permettent aux bibliothèques d'exister et d'évoluer sans briser chaque utilisateur de bibliothèque lorsque quelque chose change en interne. Il s'appelle Application Programming Interface , pas Application Programming Classes. Sur une plus petite échelle, ils permettent également à plusieurs développeurs de collaborer avec succès sur des projets à grande échelle, en séparant différents modules par interfaces bien documentées.

les classes Abstraites sont de haute cohésion helpers pour être utilisé lors de la mise en œuvre d'une interface, en supposant un niveau de détails de mise en œuvre. Par ailleurs, des classes abstraites sont utilisées pour définir les interfaces SPI, fournisseurs de services.

la différence entre une API et un SPI est subtile, mais importante: pour une API, le focus est sur qui utilise it, et pour un SPI le focus est sur qui met en œuvre il.

ajouter des méthodes à une API est facile, tous les utilisateurs existants de l'API compilera toujours. Ajouter des méthodes à une IPS est difficile, puisque chaque fournisseur de services (mise en œuvre concrète) devra mettre en œuvre les nouvelles méthodes. Si des interfaces sont utilisées pour définir une IPS, un fournisseur devra publier une nouvelle version chaque fois que le contrat de L'IPS sera modifié. Si des classes abstraites sont utilisées à la place, de nouvelles méthodes pourraient être définies dans termes des méthodes abstraites existantes, ou comme des talons vides throw not implemented exception , qui permettront au moins à une version plus ancienne d'une implémentation de service de continuer à compiler et à exécuter.

une note sur Java 8 et les méthodes par défaut

bien que Java 8 ait introduit des méthodes par défaut pour les interfaces, ce qui rend la ligne entre les interfaces et les classes abstraites encore plus floue, ce n'était pas pour que les implémentations puissent réutiliser le code, mais pour rendre plus facile de changer les interfaces qui servent à la fois D'API et de SPI (ou sont utilisés à tort pour définir SPIs au lieu de classes abstraites).

Lequel utiliser?

  1. est-ce que la chose est supposée être utilisée publiquement par d'autres parties du code, ou par d'autres codes externes? Ajouter une interface pour cacher les détails de la mise en œuvre du contrat abstrait public, qui est le comportement général de la chose.
  2. est-ce que est quelque chose qui est supposé avoir plusieurs implémentations avec beaucoup de code en commun? Créer à la fois une interface et une implémentation abstraite et incomplète.
  3. y aura-t-il jamais une seule mise en œuvre, et personne d'autre ne l'utilisera? Il suffit de faire une classe concrète.
    1. "jamais" est longue de temps, vous pouvez jouer en toute sécurité et toujours ajouter une interface sur le dessus de cela.

un corollaire: l'inverse est souvent mal fait: lorsque vous utilisez une chose , toujours essayer d'utiliser la classe/interface la plus générique dont vous avez réellement besoin. En d'autres termes, ne déclarez pas vos variables comme ArrayList theList = new ArrayList() , à moins que vous ayez réellement une dépendance très forte sur elle étant une liste tableau , et aucun autre type de liste ne le couperait pour vous. Utilisez List theList = new ArrayList à la place, ou même Collection theCollection = new ArrayList si le le fait que ce soit une liste, et pas n'importe quel autre type de collection n'a pas vraiment d'importance.

3
répondu Sergiu Dumitriu 2016-06-19 12:02:34
la source

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 les classes abstraites lorsque vous vous attendez à des changements dans votre contrat, c'est-à-dire, par exemple dans le futur, vous pourriez avoir besoin d'ajouter une nouvelle méthode.

Dans cette situation, si vous décidez d'utiliser une interface, lorsque l'interface est modifié pour inclure l'interface, votre application se cassera lorsque vous avez jeté la dll nouvelle interface.

pour lire en détail, visitez différence entre la classe abstraite et une interface

3
répondu Ranganatha 2016-06-30 19:27:45
la source

j'aimerais ajouter une autre différence qui a du sens. Par exemple, vous avez un cadre avec des milliers de lignes de code. Maintenant, si vous voulez ajouter une nouvelle fonctionnalité tout au long du code en utilisant une méthode enhanceUI(), alors il est préférable d'ajouter cette méthode dans la classe abstraite plutôt que dans l'interface. Parce que, si vous ajoutez cette méthode dans une interface alors vous devriez l'implémenter dans toute la classe implémentée mais ce n'est pas le cas si vous ajoutez la méthode dans la classe abstract.

3
répondu Toothless 2016-12-15 20:47:09
la source

les Différences entre l'abstrait classe et d'interface pour le compte de la réelle mise en œuvre.

Interface : c'est un mot-clé et il est utilisé pour définir le modèle ou l'impression bleue d'un objet et il force toutes les sous-classes suivraient le même prototype,comme pour la mise en œuvre, toutes les sous-classes sont libres de mettre en œuvre la fonctionnalité selon ses besoins.

certains autres cas d'utilisation où nous devrions utiliser l'interface.

Communication entre deux objets externes(intégration de tiers dans notre application) fait à travers Interface ici L'Interface fonctionne comme un contrat.

Classe Abstraite: Abstrait,c'est un mot-clé et lorsque nous utilisons ce mot-clé devant toute la classe, puis il devient classe abstraite.Il est principalement utilisé lorsque nous avons besoin de définir le modèle ainsi que certaines fonctionnalités par défaut d'un objet qui est suivi par toutes les sous-classes et de cette façon il supprime le code redondant et un cas d'utilisation de plus où nous pouvons utiliser la classe abstraite , comme nous ne voulons pas d'autres classes peuvent 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");
        }
    }
3
répondu Sheo Dayal Singh 2017-08-18 08:56:01
la source

vous pouvez trouver une différence claire entre interface et classe abstraite.

Interface

  • Interface contient seulement des méthodes abstraites.
  • Forcer les utilisateurs à mettre en œuvre toutes les méthodes de implémente l'interface.
  • contient seulement des variables finales et statiques.
  • déclarer en utilisant l'interface mot.
  • toutes les méthodes d'une interface doivent être définies comme publiques.
  • Une interface peut étendre ou une classe peut implémenter plusieurs autres interface.

la classe Abstraite

  • classe Abstraite contient abstrait et non des méthodes abstraites.

  • Ne pas forcer les utilisateurs à mettre en œuvre toutes les méthodes de hérité de la la classe abstraite.

  • contient toutes sortes de variables, y compris primitives et non primitives

  • Déclarer à l'aide de mot clé abstract.

  • les méthodes et les membres d'une classe abstraite peuvent être définis avec visibilité.

  • une classe d'enfants ne peut étendre qu'une seule classe (abstraite ou concrète).

3
répondu Rahul Chauhan 2017-08-24 17:05:09
la source

enter image description here

Voici une compréhension de base sur l'interface vs classe abstraite.

2
répondu Santosh 2016-01-22 15:24:54
la source

une classe abstraite est une classe dont l'objet ne peut être créé ou une classe qui ne peut être instanciée. Une méthode abstraite rend une classe abstraite. Une classe abstraite doit être héréditaire, afin de remplacer les méthodes qui sont déclarées dans la classe abstraite. Aucune restriction sur les spécificateurs d'accès. Une classe abstraite peut avoir des méthodes de constructeur et d'autres méthodes concrètes(méthodes non absarct ) mais l'interface ne peut pas avoir.

une interface est un plan directeur / modèle de méthodes.(eg. Une maison sur papier est donnée(maison d'interface) et différents architectes utiliseront leurs idées pour la construire (les classes d'architectes mettant en œuvre l'interface maison) . Il s'agit d'un ensemble de méthodes abstraites , de méthodes par défaut , de méthodes statiques , de variables finales et de classes imbriquées. Tous les membres seront soit définitifs , soit publics, protégés et les spécificateurs d'accès privés ne sont pas autorisés.Aucune création d'objet n'est autorisée. Une classe doit être faite afin d'utiliser le implémenter l'interface et aussi de surcharger 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.Il indique quoi faire mais comment faire est défini par la classe d'implémentation. Pour Eg. Il ya une entreprise automobile et il veut que certaines fonctionnalités d'être les mêmes pour toutes les voitures qu'il est de fabrication afin que la société serait de faire un véhicule d'interface qui aura les caractéristiques et les différentes classes de voiture(comme Maruti Suzkhi , Maruti 800) supplanteront ces caractéristiques (fonctions).

pourquoi interface alors que nous avons déjà la classe abstraite? Java ne prend en charge que l'héritage multiniveau et hiérarchique, mais avec l'aide de l'interface, nous pouvons mettre en œuvre l'héritage multiple.

2
répondu Tutu Kumari 2016-09-20 22:19:45
la source

pour donner une réponse simple mais claire, cela aide à définir le contexte : vous utilisez les deux lorsque vous ne voulez pas fournir des implémentations complètes.

la principale différence est alors qu'une interface n'a aucune implémentation du tout (seulement des méthodes sans corps) tandis que les classes abstraites peuvent avoir des membres et des méthodes avec un corps aussi bien, c'est-à-dire qu'elles peuvent être partiellement implémentées.

2
répondu user3775501 2017-06-28 13:49:48
la source

dans une interface toutes les méthodes doivent être uniquement des définitions, pas une seule doit être mise en œuvre.

mais dans une classe abstraite il doit y avoir une méthode abstraite avec seulement définition, mais d'autres méthodes peuvent aussi être dans la classe abstraite avec implémentation...

1
répondu Shamim Ahmed 2016-11-20 17:25:09
la source

j'ai lu une explication simple mais efficace de la classe abstraite et de L'Interface sur php.net

, comme suit:

une Interface est comme un protocole. Il ne désigne pas le comportement de l'objet; il désigne comment votre code indique à cet objet d'agir. Une interface serait comme la langue anglaise: définir une interface définit comment votre code communique avec n'importe quel 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 a".

d'un autre côté, une classe abstraite est comme une classe partiellement construite. C'est un peu comme un document avec des blancs à remplir. Il pourrait être l'utilisation de l'anglais, mais ce n'est pas aussi important que le fait qu'une partie du document est déjà écrit.

An classe abstraite est la base pour un autre objet. Quand une classe dit "j'étends la classe abstraite Y", elle dit "j'utilise certaines méthodes ou propriétés déjà définies dans cette autre classe appelée Y".

ainsi, 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 auriez votre classe implémenter une interface particulière si vous distribuiez une classe à être utilisée par d'autres personnes. L'interface est un contrat d'une série de méthodes pour votre classe.

vous auriez votre classe étendre une classe abstraite si vous (ou quelqu'un d'autre) avez écrit une classe qui avait déjà quelques méthodes écrites que vous voulez utiliser dans votre nouvelle classe.

Ces concepts, bien que faciles à confondre, sont spécifiquement différents et distincts. Pour toutes fins utiles, si vous êtes le seul utilisateur de l'une de vos classes, vous n'avez pas besoin d'implémenter des interfaces.

1
répondu Vatsal Shah 2018-05-23 12:19:35
la source

Autres questions sur oop interface abstract-class