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).

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.

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

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.

quelques différences importantes:

sous forme de tableau:

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.

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?

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.

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.

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

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.

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é.

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.

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.

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? .

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"

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.

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, ...

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..

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.

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 /

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 .

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.