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

Interfaces

Une interface est une contrat: La personne qui écrit l'interface dit, "hey, j'accepte les choses à la recherche de cette façon", et la personne à l'aide de l'interface dit "OK, la classe j'écris regarde de cette façon".

Une interface est une coquille 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;
    }
}

Mise en œuvre d'une interface consomme peu de CPU, parce que ce n'est pas une classe, tout un tas de noms, et par conséquent, il n'est pas cher recherche à faire. C'est génial quand il le faut, comme dans les systèmes embarqués.

---

Les classes abstraites

Les classes abstraites, à la différence des interfaces, sont des classes. Ils sont plus chers à l'usage, car il y a une recherche à faire quand vous en hérite.

Les classes abstraites ressemblent beaucoup à des interfaces, mais ils ont quelque chose de plus: Vous pouvez définir un comportement pour eux. C'est plus sur une personne en disant: "ces classes doit ressembler à cela, et ils ont cela en commun, afin de remplir 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");
    }
}

---

Mise en œuvre

Tandis que les classes abstraites et les interfaces sont censés être différents concepts, les implémentations de faire cette déclaration, parfois faux. Parfois, ils sont même pas ce que vous pensez qu'ils sont.

En Java, cette règle est appliquée rigoureusement, tout en PHP, les interfaces sont des classes abstraites sans méthode déclarée.

En Python, les classes abstraites sont plus d'une programmation astuce vous pouvez obtenir de l'ABC module et est fait à l'aide metaclasses, et donc des classes. Et les interfaces sont plus liées à la duck-typing dans cette langue, et c'est un mélange entre les conventions et les méthodes spéciales qui appellent des descripteurs (l' __méthode__ méthodes).

Comme d'habitude avec la programmation, il y a la théorie, la pratique, et la pratique dans une autre langue 🙂

Une Interface ne contient que la définition et la signature de la fonctionnalité, et si nous avons certaines fonctionnalités communes, ainsi que des signatures, alors nous avons besoin d'utiliser une classe abstraite. En utilisant une classe abstraite, on peut prévoir le comportement ainsi que des fonctionnalités les deux en même temps. Un autre développeur hériter de la classe abstraite pouvez utiliser cette fonctionnalité facilement, car ils ont besoin pour remplir les blancs.

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

Je ne veux pas mettre en évidence les différences, qui ont été déjà dit dans plusieurs réponses ( concernant le public static final modificateurs pour les variables de l'interface & soutien à l'protégé, privé des méthodes dans les classes abstraites)

En termes simples, je voudrais dire:

interface: À l'exécution d'un contrat par de multiples objets indépendants

classe abstraite: Pour mettre en œuvre les mêmes ou différents comportements entre plusieurs objets liés à l'

De l'Oracle la documentation

Envisager l'utilisation de classes abstraites si :

1. Vous souhaitez partager du code entre plusieurs étroitement liées classes.
2. Vous vous attendez à ce que les classes qui étendent la classe abstraite ont beaucoup de méthodes communes ou dans les champs, ou d'exiger des modificateurs d'accès autres que publics (tels que privé et protégé).
3. Vous voulez déclarer la non-statique ou non-final champs.

Envisager d'utiliser des interfaces si :

1. Vous vous attendez à ce que les classes indépendantes serait la mise en œuvre de votre interface. Par exemple,de nombreux objets indépendants peuvent mettre en œuvre Serializable interface.
2. Vous souhaitez spécifier le comportement d'un type de données particulier, mais pas un sujet de préoccupation 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. l'interface fournit "a une" capacité pour les classes.

Si vous êtes à la recherche pour Java comme langage de programmation, voici quelques mises à jour:

Java 8 a réduit l'écart entre interface et abstract classes dans une certaine mesure, en fournissant un default fonctionnalité de méthode. Une interface ne dispose pas d'une mise en œuvre d'une méthode n'est plus valable aujourd'hui.

Référence à cette documentation page pour plus de détails.

Jetez un oeil à cette question SE pour des exemples de code pour mieux comprendre.

Comment dois-je avoir expliqué la différence entre une Interface et une classe Abstraite?

Le point principal est que:

• Abstrait est orienté objet. Il offre la base de données un "objet" doit avoir et/ou des fonctions qu'il devrait être en mesure de le 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 fonctionnalité orientée. Il définit les fonctionnalités d'un objet doit avoir. Peu importe ce que l'objet qu'il veut, tant qu'il peut faire ces fonctionnalités, qui sont définies dans l'interface, c'est la fin. Il ignore tout le reste. Un objet/classe peut contenir plusieurs (groupes de) fonctionnalités; par conséquent, il est possible pour une classe d'implémenter plusieurs interfaces.

Je suis la construction d'un bâtiment de 300 étages

La construction du plan interface

• Par exemple, Servlet(I)

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

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

De construction de l'immeuble terminée-béton

• La pleine mise en œuvre, par exemple, propre servlet

Interface

• Nous ne savons rien au sujet de la mise en œuvre, justes exigences. Nous pouvons
  aller pour une interface.
• Chaque méthode est publique et abstrait par défaut
• C'est un 100% pur classe abstraite
• Si nous déclarer en public que l'on ne peut pas déclarer privé et protégé
• Si nous déclarer abstraite, nous ne pouvons pas déclarer final, statique, synchronisé, strictfp et natif
• Chaque interface avec le public, static et final
• La sérialisation et transitoire n'est pas applicable, parce que nous ne pouvons pas créer une instance de l'interface
• Non volatile car elle est définitive
• Chaque variable est statique
• Lors de la déclaration d'une variable à l'intérieur d'une interface, nous devons initialiser des variables, tout en déclarant
• Instance et statique bloc non autorisés

Résumé

• Mise en œuvre partielle
• Il a une méthode abstraite. Un plus, elle utilise des
• Pas de restriction pour le résumé de la méthode de classe modificateurs
• Aucune restriction pour la classe abstraite les modificateurs de variables
• On ne peut pas déclarer d'autres modificateurs, sauf résumé
• Pas de restriction pour initialiser des variables

Prises de DurgaJobs Site

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 "déclarer" et de ne pas définir le comportement que vous souhaitez le cours.

Une classe abstraite permet de faire déclarer (à l'aide de méthodes abstraites) ainsi que de définir (en utilisant la méthode complète implémentations) le comportement que vous souhaitez le cours.

Et une classe ordinaire ne permet de définir, de ne pas déclarer, le comportement/les actions que vous souhaitez que la classe d'avoir.

Une dernière chose,

En Java, on peut implémenter plusieurs interfaces, mais vous ne pouvez étendre un (Classe Abstraite ou une Classe)...

Cela signifie l'héritage de comportement défini est limité à un seul par classe... c'est à dire que si tu voulais une classe que encapsulé comportement de Classes A,B&C, vous aurez besoin de faire le suivant: Class A extends B, Classe C extends A .. c'est un peu un tour sur moyen d'avoir de l'héritage multiple...

Interfaces d'autre part, vous pouvez tout simplement faire: interface C implémente A, B

Donc en effet Java supporte l'héritage multiple, seule en "a déclaré le problème" ie interfaces, et seulement de l'héritage simple avec comportement défini.. à moins que vous ne le rond-point chemin que j'ai décrit...

J'espère que ça a du sens.

La seule différence est que l'on peut participer à l'héritage multiple et d'autres ne le peuvent pas.

La définition d'une interface a changé au fil du temps. Pensez-vous qu'une interface a juste des déclarations de méthode, seulement et seulement contrats? Qu'en est statique de la finale de variables et ce sur les définitions par défaut après Java 8?

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

Interfaces sont les constructions qui ont été créés à partir avec l'héritage multiple problème et peut avoir des méthodes abstraites, les définitions par défaut et statique de la finale de variables.

Voir Pourquoi Java permettent static final variables dans les interfaces quand ils sont uniquement destinées à des contrats?.

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

Classe Abstraite: La Roue.

Catégorie: Volant, dérive de la Roue, expose l'Interface

Est pour catégoriser les comportements qui peuvent être offerts dans un éventail diversifié de choses, l'autre est pour la modélisation d'une ontologie de choses.

Pas vraiment la réponse à la question d'origine, mais une fois que vous avez la réponse à la différence entre eux, vous entrez dans la lorsque-pour-utiliser-chaque dilemme:
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 en voyant les interfaces comme un équivalent de l'adjectif dans la grammaire a fonctionné pour moi jusqu'à maintenant (corrigez-moi si cette méthode est faux!). Par exemple, les noms d'interface sont comme des attributs ou des fonctionnalités que vous pouvez donner à une classe, et une classe peut avoir plusieurs d'entre eux: ISerializable, ICountable, IList, ICacheable, IHappy, ...

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 de définir dans l'abstrait mot clé qui doit l'emporter 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 doit l'emporter 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.
• Seulement Complète des Membres 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:

• C'est une sorte de contrat que les forces de toutes les sous-classes à porter sur le même hiérarchies ou des normes.
• Si les différentes implémentations sont de même nature et d'utiliser le bon comportement ou le statut d'une classe abstraite est le meilleur à utiliser.
• Si nous ajouter une nouvelle méthode à une classe abstraite ensuite, nous avons la possibilité de fournir à défaut de mise en œuvre et, par conséquent, tout le code existant peut fonctionner correctement.
• Ses permettre l'exécution rapide de l'interface.(interface Requiert plus de temps pour trouver la méthode dans les classes correspondantes.)
• Il peut utiliser pour serré et lâche de couplage.

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

Je voudrais ajouter encore une différence qui fait sens.
Par exemple, vous avez un cadre avec des milliers de lignes de code. Maintenant, si vous voulez ajouter une nouvelle fonctionnalité dans le code à l'aide d'une méthode enhanceUI(), alors il est préférable d'ajouter que la méthode dans la classe abstraite plutôt dans l'interface. Parce que, si vous ajoutez cette méthode dans une interface, alors vous devriez le mettre en œuvre dans toutes les mises en œuvre de la classe, mais ce n'est pas le cas si vous ajoutez la méthode dans la classe abstraite.

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 le bleu de l'impression d'un objet et il les forces, toutes les sous classes de suivre le même prototype,pour ce qui est de la mise en œuvre, toutes les sous-classes sont libres de mettre en œuvre les fonctionnalités selon que c'est la condition.

Certains à d'autres cas où l'on doit utiliser l'interface.

De Communication entre deux objets externes(Tiers de l'intégration dans notre application) fait par le biais de Interface ici, l'Interface fonctionne comme un Contrat.

Classe abstraite: Résumé,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 suivie par tous les sous-classes et de cette manière, il supprime le code redondant et un plus les cas d'utilisation où nous pouvons utiliser la classe abstraite, comme nous ne voulons pas d'autres classes peuvent directement instancier un objet de la classe, seulement 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 De L'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");
        }
    }

Beaucoup les développeurs juniors font l'erreur de penser des interfaces, concrètes et abstraites les classes en tant que de légères variations de la même chose, et de choisir l'un d'eux purement pour des raisons techniques: ai-je besoin de l'héritage multiple? Ai-je besoin d'un endroit pour mettre les méthodes courantes? Dois-je m'inquiéter d'autre chose que juste un béton de classe? C'est faux, et caché dans ces questions est le problème principal: "je". Lorsque vous écrivez du code pour vous-même, par vous-même, il est rare de penser à d'autres, présents ou futurs développeurs travaillant sur ou avec votre code.

Les Interfaces et les classes abstraites, mais apparemment similaires d'un point de vue technique, ont un sens complètement différent et fins.

Résumé

1. Une interface définit un contrat que certains de la mise en œuvre permettra de remplir pour vous.

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

Alternative résumé

1. D'une interface pour la définition des Api publiques
2. Une classe abstraite est pour un usage interne, et pour la définition de SPIs

Sur l'importance de cacher les détails de mise en œuvre

Une classe concrète le travail réel, d'une façon très spécifique. Par exemple, un ArrayList utilise un espace contigu de mémoire pour stocker une liste d'objets dans un compact manière qui offre accès aléatoire rapide, l'itération, et les modifications en place, mais elle est terrible à des insertions, des suppressions et parfois même des ajouts; pendant ce temps, un LinkedList utilise double-nœuds liés à stocker une liste d'objets, ce qui offre plutôt rapide itération, modifications en place, et à l'insertion/suppression/ajout, mais elle est terrible à 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 de serrer de performance d'une liste de ce que vous êtes fortement en interaction avec, et lors de la prise du type de liste est à vous, vous devez soigneusement choisir celui qui vous avez de l'instanciation.

D'autre part, le niveau élevé des utilisateurs de la liste ne vous souciez pas vraiment comment il est réellement mis en œuvre, et ils devraient être isolés à partir de ces détails. Imaginons que Java ne pas exposer le List interface, mais seulement eu un béton List classe qui est en fait ce que LinkedList est maintenant. Tous Java, les développeurs ont adapté leur code pour l'adapter les détails de mise en œuvre: éviter d'accès aléatoire, ajouter un cache pour accélérer l'accès, ou tout simplement ré-écrire ArrayList sur leur propre, bien que ce serait incompatible avec tout autre code qui fonctionne réellement avec List seulement. Ce serait terrible... Mais maintenant, imaginez que le Java maîtres en fait de réaliser qu'une liste chaînée est terrible pour la plupart des cas d'utilisation réels, et a décidé de passer à la liste du réseau pour leur seul List classe disponible. Cela aurait un impact sur les performances de chaque programme Java dans le monde, et les gens ne seraient pas heureux à ce sujet. Et le principal coupable est que la mise en œuvre de détails étaient disponibles, et les développeurs de supposer que ces détails sont d'un contrat permanent qu'ils peuvent compter sur. C'est pourquoi il est important de cacher les détails d'implémentation, et de se contenter de définir un résumé du contrat. C'est le but d'une interface: définir le type de saisie d'une méthode accepte, et ce type de sortie est prévu, sans s'exposer à tous les tripes qui pousserait les programmeurs de peaufiner leur code pour s'adapter à l'intérieur les détails qui pourraient changer à l'avenir toute mise à jour.

Une classe abstraite est au milieu entre les interfaces et les classes concrètes. Il est censé aider les implémentations en commun ou du code ennuyeux. Par exemple, AbstractCollection fournit des implémentations pour isEmpty basé sur la taille est de 0, contains comme itérer et de comparer, addAll, comme on le répète add, et ainsi de suite. Cela permet des implémentations de se concentrer sur les éléments essentiels qui différencient entre eux: comment stocker et récupérer des données.

Api rapport SPIs

Interfaces sont de faible cohésion passerelles entre les différentes parties de code. Ils permettent aux bibliothèques d'exister et d'évoluer sans rupture de toutes les bibliothèques de l'utilisateur lorsque quelque chose change en interne. Il est appelé de Programmation d'Application Interface, pas de Programmation d'Application des Classes. Sur une plus petite échelle, ils permettent aussi à de nombreux développeurs de collaborer avec succès sur des projets à grande échelle, en séparant les différents modules à travers des interfaces documentées.

Les classes abstraites sont de haute cohésion aides à être utilisé lors de la mise en œuvre d'une interface, en supposant un niveau de détails de mise en œuvre. Sinon, les classes abstraites sont utilisés pour la définition des Zips, Fournisseur de Services d'Interfaces.

La différence entre un API et un SPI est subtile, mais importante: pour une API, l'accent est mis sur qui utilise, et pour un SPI l'accent est mis sur qui implémente il.

Ajouter des méthodes à une API est facile, tous les utilisateurs de l'API seront encore de la compilation. Ajouter des méthodes à une SPI est difficile, car chaque fournisseur de services (mise en œuvre concrète) devra mettre en œuvre de nouvelles méthodes. Si les interfaces sont utilisées pour définir un SPI, un fournisseur de sortir une nouvelle version à chaque fois que le SPI de modifications de contrat. Si les classes abstraites sont utilisés au lieu de cela, de nouvelles méthodes pourraient être définis dans le plan des méthodes abstraites, ou comme vide throw not implemented exception talons, ce qui permettra au moins d'une version plus ancienne d'un service de la mise en œuvre de toujours compiler et exécuter.

Une remarque sur Java 8 et méthodes par défaut

Bien que Java 8 introduit des méthodes par défaut pour les interfaces, ce qui rend la ligne entre les interfaces et les classes abstraites même de plus en plus floue, ce n'était pas, de sorte que les implémentations pouvez réutiliser le code, mais pour le rendre plus facile de changer les interfaces qui servent à la fois comme une API et un SPI (ou sont mal utilisés pour la définition de SPIs au lieu de classes abstraites).

Laquelle utiliser?

1. Est le chose censé être publiquement par d'autres parties du code, ou par d'autres codes externes? Ajouter une interface de cacher les détails d'implémentation du résumé public du contrat, ce qui est le comportement général de la chose.
2. Est le chose quelque chose qui est censé avoir plusieurs implémentations avec beaucoup de code en commun? Faire à la fois d'une interface et d'un résumé, une mise en œuvre incomplète.
3. Est-il jamais va être un seul de la mise en œuvre, et personne ne va l'utiliser? 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, à tort, fait: lors de l'utilisation d'un chose, essayez toujours d'utiliser la plupart des génériques de la classe/de l'interface que vous avez réellement besoin. En d'autres termes, de ne pas déclarer vos variables comme ArrayList theList = new ArrayList(), sauf si vous avez une très forte dépendance à l'égard étant un tableau liste, et aucun autre type de liste de le couper pour vous. Utilisation List theList = new ArrayList au lieu de cela, ou même Collection theCollection = new ArrayList si le fait que c'est une liste, et pas n'importe quel autre type de collection n'est pas vraiment de l'importance.

Dans une interface toutes les méthodes doivent être uniquement des définitions, pas un seul devrait être mis en œuvre.

Mais dans une classe abstraite, il faut une méthode abstraite avec une seule définition, mais d'autres méthodes peuvent également être dans la classe abstraite avec la mise en œuvre...

Un simple mais efficace, l'explication de la classe abstraite et une interface sur php.net:

Une Interface est semblable à un protocole. Il ne désigne le comportement de l'objet; il désigne la façon dont votre code indique que l'objet de la loi. Une interface serait comme la Langue anglaise: la définition d'une interface définit la façon dont votre code communique avec un objet implémentant cette interface.

Une interface est toujours un contrat ou d'une promesse. Lorsqu'une classe dit "je implémenter l'interface Y", c'est dire "je promets d'avoir les mêmes méthodes publiques n'importe quel objet avec une interface Y a".

D'autre part, une Classe Abstraite est comme une partie construite de la classe. 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.

Une classe abstraite est la base pour un autre objet. Lorsqu'une classe dit "je étendre la classe abstraite Y", c'est dire "j'utilise des méthodes ou des propriétés déjà définies dans cette autre classe nommée Y".

Donc, considérez les points suivants PHP:

<?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émente une interface particulière si vous étiez de la distribution d'une classe à être utilisé par d'autres personnes. L'interface est un contrat d'une série de méthodes pour votre classe.

Vous auriez votre classe d'étendre une classe abstraite si vous (ou quelqu'un d'autre) a écrit une classe qui avaient déjà de méthodes écrites que vous souhaitez 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.

Voici un très compréhension de base sur l'interface vs classe abstraite.

Nous avons différentes structures ou de syntaxe différence entre l'interface et la classe abstraite. Certains plus de différences sont

[1] Scénario de différence:

Les classes abstraites sont utilisés dans les scénarios quand nous voulons nous limiter à l'utilisateur de créer un objet de la classe parente, ET nous croyons qu'il y aura plus de méthodes abstraites seront ajoutés dans le futur.

Interface doit être utilisé lorsque nous sommes sûr qu'il y a peut-être pas plus méthode abstraite de gauche à fournir. Alors seulement une interface est publié.

[2] différence Conceptuelle:

"Nous devons fournir plus abstrait des méthodes à l'avenir" si OUI, il classe abstraite et si PAS de faire de l'Interface.

(Plus approprié et valide jusqu'java 1.7)