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

Difference between abstract class and interface

1. les classes Abstraites rapport à des interfaces en Java 8
2. Différence Conceptuelle:

de l'Interface par Défaut des Méthodes en Java 8

1. Qu'est-ce que la méthode par défaut?
2. ForEach method erreur de compilation résolu en utilisant la méthode par défaut
3. méthode par défaut et Multiple Ambigüity Problems
4. points importants concernant les méthodes par défaut de l'interface java:

Java De L'Interface De La Méthode Statique

1. Interface Java Méthode Statique, exemple de code, la méthode statique vs méthode par défaut
2. points importants à propos de la méthode statique Java interface:

Java Interfaces Fonctionnelles

---

---

les classes Abstraites rapport à des interfaces en Java 8

Java 8 les changements d'interface incluent les méthodes statiques et les méthodes par défaut dans interface. Avant Java 8, nous ne pouvions avoir que des déclarations de méthode interface. Mais à partir de Java 8, nous pouvons avoir des méthodes par défaut et méthodes statiques dans les interfaces.

après avoir introduit la méthode par défaut, il semble que les interfaces et les classes abstraites sont de même. Cependant, ils sont encore différents concept en Java 8.

classe Abstraite peut définir constructeur. Ils sont plus structurés et peut avoir un état associé avec eux. Tandis qu'à l'inverse, par défaut méthode ne peut être mise en œuvre que dans les Termes d'invoquer d'autres les méthodes d'interface, sans référence à une implémentation particulière état. Par conséquent, à la fois l'utilisation à des fins différentes et le choix entre deux dépend vraiment sur le scénario.

Différence Conceptuelle:

les classes Abstraites sont valables pour squelettiques (c'est à dire partielle) des implémentations des interfaces, mais ne devrait pas exister sans un correspondant de l'interface.

Ainsi, lorsque les classes abstraites sont effectivement réduites à une faible visibilité, les implémentations squelettiques des interfaces, les méthodes par défaut peuvent-elles supprimer cela aussi? Décidément: Non! La mise en œuvre d'interfaces nécessite presque toujours une partie ou la totalité de ces outils méthodes par défaut manque. Et si une interface ne le fait pas, c'est clairement un cas spécial, qui ne devrait pas vous égarer.

de l'Interface par Défaut des Méthodes en Java 8

Java 8 introduit" méthode par défaut " ou (méthodes Defender) nouvelle fonctionnalité, qui permet au développeur d'ajouter de nouvelles méthodes aux Interfaces sans briser la mise en œuvre existante de ces interfaces. Il offre une flexibilité pour permettre à L'Interface de définir mise en œuvre qui sera utilisée par défaut dans la situation où une classe concrète ne fournit pas une mise en œuvre pour cette méthode.

prenons petit exemple pour comprendre comment cela fonctionne:

public interface OldInterface {
    public void existingMethod();
 
    default public void newDefaultMethod() {
        System.out.println("New default method"
               + " is added in interface");
    }
}

la classe suivante compilera avec succès en Java JDK 8,

public class OldInterfaceImpl implements OldInterface {
    public void existingMethod() {
     // existing implementation is here…
    }
}

si vous créez une instance de OldInterfaceImpl:

OldInterfaceImpl obj = new OldInterfaceImpl ();
// print “New default method add in interface”
obj.newDefaultMethod(); 

---

Méthode Par Défaut:

les méthodes par défaut ne sont jamais finales, ne peuvent pas être synchronisées et ne peuvent pas remplacer l'Objet de méthodes. Ils sont toujours publics, ce qui sévèrement limite la capacité d'écrire des méthodes courtes et réutilisables.

Les méthodes par défaut

peuvent être fournies à une Interface sans affecter les Classes d'implémentation car elles incluent une implémentation. Si chaque méthode ajoutée dans une Interface définie avec implémentation alors aucune classe d'implémentation n'est affectée. Une classe d'implémentation peut outrepasser l'implémentation par défaut fournie par L'Interface.

Les méthodes par défaut

permettent d'ajouter de nouvelles fonctionnalités aux Interfaces existantes sans briser l'ancienne implémentation de ces Interfaces.

lorsque nous étendons une interface qui contient une méthode par défaut, nous pouvons effectuer ce qui suit,

1. Not outrepasser la méthode par défaut et héritera de la méthode par défaut.
2. outrepasser la méthode par défaut similaire à d'autres méthodes que nous outrepassons dans sous-classe.
3. Redeclare par défaut de la méthode de l'abstraction, de la force sous-classe le remplacer.

---

ForEach méthode erreur de compilation résolu en utilisant la méthode par défaut

pour Java 8, les collections JDK ont été étendues et méthode est ajouté à l'ensemble de la collection (qui fonctionnent en conjonction avec lambdas). Avec la manière conventionnelle, le code ressemble à ci-dessous,

public interface Iterable<T> {
    public void forEach(Consumer<? super T> consumer);
}

depuis ce résultat chaque classe d'implémentation avec des erreurs de compilation donc, une méthode par défaut ajoutée avec une implémentation requise afin que l'implémentation existante ne devrait pas être changée.

L'Interface itérable avec la méthode par défaut est ci-dessous,

public interface Iterable<T> {
    public default void forEach(Consumer
                   <? super T> consumer) {
        for (T t : this) {
            consumer.accept(t);
        }
    }
}

Le même mécanisme a été utilisé pour ajouter Stream dans L'Interface JDK sans casser les Classes d'implémentation.

---

Méthode par Défaut et l'Héritage Multiple Ambiguïté Problèmes

puisque la classe java peut implémenter plusieurs Interfaces et que chaque Interface peut définir la méthode par défaut avec la même signature de méthode, les méthodes héritées peuvent donc entrer en conflit les unes avec les autres.

Prenons l'exemple suivant:

public interface InterfaceA {  
       default void defaultMethod(){  
           System.out.println("Interface A default method");  
    }  
}
 
public interface InterfaceB {
   default void defaultMethod(){
       System.out.println("Interface B default method");
   }
}
 
public class Impl implements InterfaceA, InterfaceB  {
}

le code ci-dessus ne sera pas compilé avec l'erreur suivante,

java: class Impl hérite de défauts indépendants pour defaultMethod () de types InterfaceA et InterfaceB

pour corriger cette classe, nous devons fournir l'implémentation de la méthode par défaut:

public class Impl implements InterfaceA, InterfaceB {
    public void defaultMethod(){
    }
}

en outre, si nous voulons invoquer la mise en œuvre par défaut fourni par n'importe quel de super Interface plutôt que notre propre mise en œuvre, nous pouvons le faire comme suit,

public class Impl implements InterfaceA, InterfaceB {
    public void defaultMethod(){
        // existing code here..
        InterfaceA.super.defaultMethod();
    }
}

nous pouvons choisir n'importe quelle implémentation par défaut ou les deux dans le cadre de notre nouvelle méthode.

points importants sur les méthodes par défaut de l'interface java:

1. interface Java par défaut méthodes aident dans l'extension des interfaces sans avoir la peur de la rupture de la mise en œuvre des classes.
2. Les méthodes par défaut d'interface Java permettent de combler les différences entre les interfaces et les classes abstraites.
3. Java 8 les méthodes par défaut d'interface nous aideront à éviter les classes d'utilité, comme toutes les méthodes de classe de Collections peuvent être fournies dans les interfaces elles-mêmes.
4. les méthodes par défaut de L'interface Java nous aideront à supprimer les classes d'implémentation de base, nous pouvons fournir l'implémentation par défaut et les classes d'implémentation peuvent choisir laquelle à remplacer.
5. L'une des principales raisons pour introduire des méthodes par défaut dans les interfaces est d'améliorer L'API Collections en Java 8 pour prendre en charge les expressions lambda.
6. si une classe de la hiérarchie a une méthode avec la même signature, alors les méthodes par défaut deviennent sans objet. Une méthode par défaut ne peut pas remplacer une méthode de java.lang.Objet. Le raisonnement est très simple, c'est parce que Object est la classe de base pour toutes les classes java. Donc, même si nous avons Les méthodes de classe objet définies comme des méthodes par défaut dans les interfaces, elles seront inutiles car la méthode de classe objet sera toujours utilisée. C'est pourquoi pour éviter toute confusion, nous ne pouvons pas avoir de méthodes par défaut qui supplantent les méthodes de classe objet.
7. interface Java par défaut méthodes sont également appelés comme Défenseur des Méthodes ou Virtuels, les méthodes d'extension.

"1519130920 Ressource Sur Le Lien:

1. Interface avec méthodes par défaut vs classe abstraite en Java 8
2. classe Abstraite rapport à l'interface dans le JDK 8 de l'ère
3. évolution de l'Interface via l'extension virtuelle des méthodes

---

Méthode Statique Java Interface

Interface Java Méthode Statique, exemple de code, la méthode statique vs méthode par défaut

Java interface static method est similaire à la méthode par défaut sauf que nous ne pouvons pas les outrepasser dans les classes d'implémentation. Cette fonctionnalité nous aide à éviter les résultats indésirables en cas de mauvaise implémentation dans les classes d'implémentation. Nous allons examiner cela avec un exemple simple.

public interface MyData {

    default void print(String str) {
        if (!isNull(str))
            System.out.println("MyData Print::" + str);
    }

    static boolean isNull(String str) {
        System.out.println("Interface Null Check");

        return str == null ? true : "".equals(str) ? true : false;
    }
}

voyons maintenant une classe d'implémentation qui a une méthode isNull () avec une mauvaise implémentation.

public class MyDataImpl implements MyData {

    public boolean isNull(String str) {
        System.out.println("Impl Null Check");

        return str == null ? true : false;
    }

    public static void main(String args[]){
        MyDataImpl obj = new MyDataImpl();
        obj.print("");
        obj.isNull("abc");
    }
}

notez qu'isNull (String str) est une méthode de classe simple, elle ne supplante pas la méthode d'interface. Par exemple, si nous ajoutons l'annotation @Override à la méthode isNull (), il en résultera une erreur de compilation.

maintenant quand nous allons lancer l'application, nous obtenons la sortie suivante.

Interface Null Check

Impl Null Check

si nous faisons l'interface méthode de statique à par défaut, nous obtiendrons la sortie suivante.

Impl Null Check

MyData D'Impression::

Impl Null Check

la méthode statique D'interface Java n'est visible que pour les méthodes d'interface, si nous supprimons la méthode isNull() de la classe MyDataImpl, nous ne pourrons pas l'utiliser pour L'objet MyDataImpl. Cependant, comme d'autres méthodes statiques, nous pouvons utiliser interface des méthodes statiques utilisant le nom de classe. Par exemple, une déclaration valide sera:

boolean result = MyData.isNull("abc");

points importants à propos de la méthode statique Java interface:

1. interface Java méthode statique est une partie de l'interface, nous ne pouvons pas l'utiliser pour la mise en œuvre des objets de la classe.
2. interface Java statique méthodes sont bonnes pour fournir des méthodes de l'utilitaire, par exemple null vérifier, de la collecte de tri etc.
3. La méthode statique Java interface nous aide à fournir la sécurité en ne permettant pas aux classes de mise en œuvre de les outrepasser.
4. nous ne pouvons pas définir la méthode statique d'interface pour les méthodes de classe D'objet, nous obtiendrons erreur de compilateur comme "cette méthode statique ne peut pas cacher la méthode d'instance de L'objet". C'est parce que ce n'est pas autorisé en java, puisque Object est la classe de base pour toutes les classes et nous ne pouvons pas avoir une méthode statique de niveau de classe et une autre méthode d'instance avec la même signature.
5. nous pouvons utiliser des méthodes statiques d'interface java pour supprimer des classes d'utilité telles que Collections et déplacer toutes ses méthodes statiques vers l'interface correspondante, qui serait facile à trouver et à utiliser.

---

Java Functional Interfaces

avant de conclure, je voudrais vous présenter brièvement les interfaces fonctionnelles. Une interface avec exactement une méthode abstraite est connu comme Interface fonctionnelle.

Une nouvelle annotation @FunctionalInterface a été introduit pour marquer une interface comme Interface Fonctionnelle. @FunctionalInterface annotation est une installation pour éviter les blessures accidentelles ajout de méthodes abstraites dans les interfaces fonctionnelles. C'est facultatif, mais bonne pratique de l'utiliser.

Les interfaces fonctionnelles

sont attendues depuis longtemps et très recherchées par Java 8 car elles nous permettent d'utiliser des expressions lambda pour les instancier. Nouvelle package java.util.la fonction avec une série d'interfaces fonctionnelles est ajoutée pour fournir des types de cibles pour les expressions lambda et les références de méthode. Nous examinerons les interfaces fonctionnelles et les expressions lambda dans les prochains billets.

Emplacement De La Ressource:

1. Java 8 Modifications de l'Interface – méthode statique, méthode par défaut

votre explication semble décente, mais peut-être qu'on dirait que vous avez tout lu d'un manuel? :- /

ce qui m'ennuie le plus, c'est à quel point votre exemple était-il Solide? Avez-vous la peine d'inclure presque toutes les différences entre l'abstrait et interfaces?

personnellement, je suggérerais ce lien: http://mindprod.com/jgloss/interfacevsabstract.html#TABLE

pour une liste exhaustive des différences..

Espère que cela vous aide, vous et tous les autres lecteurs dans leurs futurs entretiens

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.

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

ces deux points ci-dessus est ce que je cherche lors de l'entrevue, et est un résumé assez compact. Lire la suite pour plus de détails.

Alternative "résumé de la 1519230920"

1. une interface est pour la définition des IPA publics 1519320920"
2. une classe abstraite est destinée à un usage interne et à la définition des IPs

par exemple

Pour le dire autrement: 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, les 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, les 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 d'extraire la performance d'une liste avec laquelle vous interagissez fortement, et lorsque vous choisissez le type de liste est jusqu'à vous, vous devriez soigneusement choisir celui que vous instanciez.

d'un autre côté, les utilisateurs de haut niveau d'une liste ne se soucient pas vraiment de la façon dont elle est mise en œuvre, et ils devraient être isolés 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 en fonction des détails de l'implémentation: accéder, ajouter un cache pour accélérer l'accès, ou simplement réimposer ArrayList par eux-mêmes, bien qu'il serait incompatible avec tous les autres codes qui fonctionnent réellement avec List seulement. 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 les performances de chaque programme Java dans le monde, et les gens ne serait 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 les détails internes 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 à 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 différencient entre eux: comment stocker et récupérer des données.

un Autre point de vue: APIs contre SPIs

les 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 briser chaque utilisateur de bibliothèque lorsque quelque chose change en interne. Il s'appelle programmation D'Application Interface , pas programmation D'Application Classe. 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 grâce à des 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.

le la différence entre une API et un SPI est subtile, mais importante: pour une API, l'accent est mis sur qui utilise it, et pour un SPI, l'accent est mis sur qui implements it.

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, une le fournisseur devra publier une nouvelle version chaque fois que le contrat SPI change. Si des classes abstraites sont utilisées à la place, de nouvelles méthodes pourraient être définies en termes de méthodes abstraites existantes, ou comme des talons vides throw not implemented exception , ce qui permettra 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 introduit des méthodes par défaut pour les interfaces, ce qui rend la ligne entre interfaces et classes abstraites même plus flou, ce n'était pas pour que les implémentations puissent réutiliser le code, mais pour faciliter la modification des interfaces qui servent à la fois D'API et de SPI (ou qui sont utilisées à tort pour définir les SPI au lieu des classes abstraites).

"connaissance du livre"

les détails techniques fournis dans la réponse de L'OP sont considérés comme "connaissance du livre" parce que c'est généralement l'approche utilisée à l'école et dans la plupart des livres de technologie à propos d'une langue: quoi une chose est, pas comment à l'utiliser dans la pratique, en particulier dans les applications à grande échelle.

voici une analogie: Supposez que la question était:

Qu'est-ce qu'il y a de mieux à louer pour une nuit de bal, une voiture ou une chambre d'hôtel?

la réponse technique ressemble à:

eh Bien, dans une voiture, vous pouvez le faire plus tôt, mais dans une chambre d'hôtel, vous pouvez le faire plus confortablement. D'autre part, la chambre d'hôtel est dans un seul endroit, alors que dans la voiture, vous pouvez le faire dans plus d'endroits, comme, disons que vous pouvez aller sur le point de vista pour une belle vue, ou dans un drive-in theater, ou de nombreux autres endroits, ou même dans plus d'un endroit. Aussi, l'hôtel dispose d'une salle de douche.

C'est tout à fait vrai, mais passe complètement à côté des points qu'ils sont deux choses complètement différentes, et les deux peuvent être utilisé en même temps à des fins différentes, et l'aspect "le faire" n'est pas la chose la plus importante au sujet de l'une ou l'autre des deux options. La réponse manque de perspective, elle montre une façon immature de penser, tout en présentant correctement de vrais "faits".

Une interface est un "contrat" où la classe qui implémente le contrat promet de mettre en œuvre les méthodes. Un exemple où je devais écrire une interface au lieu d'une classe était quand je mettais à niveau un jeu de 2D à 3D. J'ai dû créer une interface pour partager les classes entre la version 2D et la version 3D du jeu.

package adventure;
import java.awt.*;
public interface Playable {
    public void playSound(String s);
    public Image loadPicture(String s);    
}

Alors je peux mettre en œuvre les méthodes basées sur l'environnement, tout en étant en mesure d'appeler les méthodes d'un objet qui ne sait pas quelle version du jeu est chargée.

public class Adventure extends JFrame implements Playable

public class Dungeon3D extends SimpleApplication implements Playable

public class Main extends SimpleApplication implements AnimEventListener, ActionListener, Playable

typiquement, dans le monde de gameworld, le monde peut être une classe abstraite qui exécute des méthodes sur le jeu:

public abstract class World...

    public Playable owner;

    public Playable getOwner() {
        return owner;
    }

    public void setOwner(Playable owner) {
        this.owner = owner;
    }

les classes Abstraites sont destinés à être héréditaire, et lorsqu'une classe hérite d'une autre cela signifie qu'il existe une relation forte entre les 2 classes. Avec une interface d'autre part, la relation entre l'interface et la classe implémentant l'interface n'est pas nécessairement très fort. Ainsi, nous pouvons résumer ce premier point en disant qu'une classe abstraite serait plus approprié quand il ya une forte relation entre la classe abstraite et l' des classes qui en découleront. Encore une fois, c'est parce qu'une classe abstraite est très étroitement liée à l'héritage, ce qui implique une forte relation. Mais, avec les interfaces, il n'est pas nécessaire qu'il y ait une relation étroite entre l'interface et les classes qui implémentent l'interface. L'interface Java peut étendre l'interface multiple aussi la classe Java peut implémenter plusieurs interfaces, ce qui signifie que l'interface peut fournir plus de soutien au polymorphisme que la classe abstraite . En étendant la classe abstraite une classe peut seulement participer à une hiérarchie de Type mais en utilisant l'interface il peut faire partie de plusieurs hiérarchies de type.

pour implémenter l'interface en Java, jusqu'à ce que votre classe soit abstraite, vous devez fournir l'implémentation de toutes les méthodes, ce qui est très douloureux. D'un autre côté, la classe abstract peut vous aider dans ce cas en fournissant une implémentation par défaut.

Que penser de la manière suivante:

• Une relation entre une classe et une classe abstraite est de type "est-un"
• Une relation entre une classe et une interface est de type "est-un"

ainsi quand vous avez une classe de résumé mammifères, une sous-classe humaine, et une interface de conduite, alors vous pouvez dire

• chaque être humain est un mammifère
• chacun L'homme a-une Conduite (comportement)

ma suggestion est que la phrase de connaissance du livre indique qu'il voulait entendre la différence sémantique entre les deux (comme d'autres ici ont déjà suggéré).

les classes Abstraites ne sont pas de la pure abstraction bcz sa collection de béton(mis en œuvre des méthodes) ainsi que des méthodes non implémentées. Mais Les Interfaces sont purement abstraction bcz il n'existe que des méthodes non mises en œuvre et non des méthodes concrètes.

pourquoi des classes abstraites?

1. si l'utilisateur veut écrire la fonctionnalité commune pour tous les objets.
2. les classes Abstraites sont le meilleur choix pour des émules dans d' futur que pour ajouter plus de fonctionnalité sans affecter l'utilisateur final.

Pourquoi Des Interfaces?

1. si l'utilisateur veut écrire différentes fonctionnalités qui seraient différentes fonctionnalités sur les objets.
Les Interfaces
2. sont le meilleur choix, s'il n'est pas nécessaire de modifier les exigences une fois l'interface publiée.

la principale différence que j'ai observée est que la classe abstraite nous fournit un comportement commun déjà mis en œuvre et les sous-classes ont seulement besoin de mettre en œuvre une fonctionnalité spécifique correspondant à eux. où comme pour une interface ne précisera que les tâches qui doivent être faites et aucune implémentation ne sera donnée par interface. Je peux dire qu'il spécifie le contrat entre lui-même et les classes implémentées.

un interface est comme un ensemble de gènes qui sont publiquement documentés pour avoir une sorte d'effet: un test ADN me dira si je les ai - et si je le fais, je peux publiquement faire savoir que je suis un" porteur " et une partie de mon comportement ou de mon état se conformera à eux. (Mais bien sûr, je peux avoir beaucoup d'autres gènes qui fournissent des traits en dehors de cette portée.)

Un la classe abstraite , c'est comme l'ancêtre mort d'un de même sexe en espèces (*): Elle ne peut pas être ramené à la vie, mais une vie (c'est à dire abstrait ) descendant hérite de tous ses gènes.

(*) Pour étirer cette métaphore, disons que tous les membres de l'espèce vivre au même âge. Cela signifie que tous les ancêtres d'un ancêtre mort doivent aussi être morts - et de même, tous les descendants d'un ancêtre vivant doivent être vivants.

je fais des interviews pour le travail et je regarderais aussi défavorablement sur votre réponse (désolé mais je suis très honnête). On dirait que vous avez lu sur la différence et révisé une réponse, mais peut-être que vous ne l'avez jamais utilisé dans la pratique.

Une bonne explication de pourquoi vous devez utiliser chacun peut être beaucoup mieux que d'avoir une explication précise de la différence. Les employeurs veulent ultimatley programmeurs de faire des choses ne les connaissent pas qui peuvent être difficiles à démontrer dans un entrevue. La réponse que vous avez donnée serait bonne si vous postuliez pour un emploi technique ou basé sur la documentation, mais pas pour un rôle de développeur.

la Meilleure chance avec des interviews dans l'avenir.

ma réponse à cette question porte davantage sur la technique d'entrevue que sur le matériel technique que vous avez fourni. Peut-être envisager de lire à ce sujet. https://workplace.stackexchange.com / peut être un excellent endroit pour ce genre de choses.

une interface est purement abstraite. nous n'avons pas de code d'implémentation dans l'interface.

classe abstraite contient à la fois les méthodes et sa mise en œuvre.

Cliquez ici pour voir le tutoriel sur les interfaces et les classes abstraites

la principale différence que j'ai observée est que la classe abstraite nous fournit un comportement commun déjà mis en œuvre et les sous-classes ont seulement besoin de mettre en œuvre une fonctionnalité spécifique correspondant à eux. où comme pour une interface ne précisera que les tâches qui doivent être faites et aucune implémentation ne sera donnée par interface. Je peux dire qu'il spécifie le contrat entre lui-même et les classes implémentées.

même si j'ai fait face à la même question dans plusieurs entrevues et croyez-moi, cela rend votre temps misérable de convaincre l'intervieweur. Si j'ai inhérent toutes les réponses d'en haut alors je dois ajouter un point clé pour le rendre plus convaincant et en utilisant OO à son meilleur

dans le cas où vous n'êtes pas planifier toute modification dans les règles , pour la sous-classe à suivre, pour un long avenir, aller pour l'interface, comme vous ne serez pas en mesure de modifier, et, si vous le faites, vous devez aller pour le changement de tous les autres sous-classes, alors que, si vous pensez, vous voulez réutiliser les fonctionnalités, définir des règles, et de rendre l'ouvrir pour modification , rendez-vous pour la classe Abstraite.

pensez de cette façon, vous aviez utilisé un service consommable ou vous aviez fourni un certain code à world et vous avez une chance de modifier quelque chose, supposons un contrôle de sécurité Et si je suis un consommateur du code et un matin après une mise à jour, je trouve toutes les marques de lecture dans mon éclipse, l'application entière est en baisse. Ainsi, pour prévenir de tels cauchemars, utilisez des Interfaces abstraites

je pense que cela pourrait convaincre l'Interviewer dans une certaine mesure...Heureux Les Entretiens À Venir.

vous choisissez Interface en Java pour éviter le problème de diamant dans l'héritage multiple .

si vous voulez que toutes vos méthodes soient implémentées par votre client, optez pour interface. Cela signifie que vous concevez l'ensemble de la demande à abstract.

Vous choisissez la classe abstraite si vous savez déjà ce qui est en commun. Par exemple, prenez une classe abstraite Car . À un niveau plus élevé, vous mettez en œuvre les méthodes de voiture communes comme calculateRPM() . C'est une méthode courante et vous laissez le client implémenter son propre comportement comme

calculateMaxSpeed() etc. Vous auriez probablement expliqué en donnant quelques exemples en temps réel que vous avez rencontrés dans votre travail quotidien.

lorsque j'essaie de partager le comportement entre deux classes étroitement liées, je crée une classe abstraite qui détient le comportement commun et sert de parent aux deux classes.

lorsque j'essaie de définir un Type, une liste de méthodes qu'un utilisateur de mon objet peut utiliser de manière fiable, alors je crée une interface.

par exemple, Je ne créerais jamais une classe abstraite avec une sous-classe concrète parce que les cours abstraits sont sur le comportement de partage. Mais je pourrais très bien créer une interface avec une seule implémentation. L'utilisateur de mon code ne savent pas qu'il existe une seule application. En effet, dans une future version, il peut y avoir plusieurs implémentations, qui sont tous des sous-classes d'une nouvelle classe abstraite qui n'existait même pas quand j'ai créé l'interface.

qui aurait pu sembler un peu trop bookish trop (bien que je ne l'ai jamais vu écrit de cette façon n'importe où que je me souviens). Si l'intervieweur (ou le PO) voulait vraiment plus de mon expérience personnelle à ce sujet, j'aurais été prêt avec des anecdotes d'une interface a évolué par nécessité et vice versa.

encore une chose. Java 8 vous permet maintenant de mettre du code par défaut dans une interface, brouillant encore plus la ligne entre les interfaces et les classes abstraites. Mais d'après ce que j'ai vu, cette fonctionnalité est surutilisée même par les fabricants du Java core bibliothèque. Cette fonctionnalité a été ajoutée, et à juste titre, pour permettre d'étendre une interface sans créer d'incompatibilité binaire. Mais si vous faites un tout nouveau Type en définissant une interface, alors l'interface devrait être juste une interface. Si vous voulez également fournir du code commun, alors par tous les moyens faire une classe helper (abstrait ou concret). Ne encombrez pas votre interface dès le début avec des fonctionnalités que vous voudrez peut-être changer.

D'après ce que j'ai compris, une Interface, qui est composée de variables finales et de méthodes sans implémentation, est implémentée par une classe pour obtenir un groupe de méthodes ou de méthodes qui sont liées entre elles. D'un autre côté, une classe abstraite, qui peut contenir des variables et des méthodes non finales avec des implémentations, est généralement utilisée comme guide ou comme superclasse dont héritent toutes les classes apparentées ou similaires. En d'autres termes, une classe abstraite contient tous les méthodes / variables qui sont partagées par toutes ses sous-classes.

dans la classe abstraite, vous pouvez écrire l'implémentation par défaut des méthodes! Mais dans Interface vous ne pouvez pas. Pour l'essentiel, Dans l'interface, il existe des méthodes virtuelles pures qui doivent être implémentées par la classe qui implémente l'interface.

hmm maintenant les gens sont affamés approche pratique, vous avez tout à fait raison, mais la plupart des intervieweurs regarde selon leur exigence actuelle et veulent une approche pratique.

après avoir terminé votre réponse, vous devez sauter sur l'exemple:

résumé:

par exemple nous avons la fonction de salaire qui ont un certain paramètre commun à tous les employés. alors nous pouvons avoir une classe abstraite appelée CCT avec corps de méthode partiellement défini et il obtiendra étend par tout type d'employé et obtenir racheté selon leurs avantages supplémentaires. Pour les communes functonality.

public abstract class CTC {

    public int salary(int hra, int da, int extra)
    {
        int total;
        total = hra+da+extra;
        //incentive for specific performing employee
        //total = hra+da+extra+incentive;
        return total;
    }
}

class Manger extends CTC
{
}


class CEO extends CTC
{
}

class Developer extends CTC
{   
}

Interface

interface en java permettre d'avoir la fonctionnalité interfcae sans étendre celui - ci et vous devez être clair avec la mise en œuvre de la signature de fonctionnalité que vous voulez introduire dans votre application. il vous forcera à avoir la définition donnée. Pour une fonctionnalité différente. public interface EmployeType 151930920"

    public String typeOfEmployee();
}

class ContarctOne implements EmployeType
{

    @Override
    public String typeOfEmployee() {
        return "contract";
    }

}

class PermanentOne implements EmployeType
{

    @Override
    public String typeOfEmployee() {
        return "permanent";
    }

}

vous pouvez avoir une telle activité forcée avec la classe abstraite aussi par des méthodes définies comme abstraites, maintenant une classe qui étend la classe abstraite remin abstract one jusqu'à ce qu'elle supplante cette fonction abstraite.

Oui, vos réponses étaient techniquement correctes, mais là où vous avez mal agi, c'était de ne pas leur montrer que vous comprenez les avantages et les inconvénients de choisir l'un plutôt que l'autre. En outre, ils étaient probablement préoccupés/paniqué sur la compatibilité de leur codebase avec les mises à niveau à l'avenir. Ce type de réponse peut avoir aidé (en plus de ce que vous avez dit):

" choisir une classe abstraite plutôt qu'une classe D'Interface dépend de ce que nous le projet l'avenir de ce code.

les classes abstraites permettent une meilleure compatibilité vers l'avant parce que vous pouvez continuer à ajouter du comportement d'une Classe Abstraite dans l'avenir sans casser votre code existant --> ce n'est pas possible avec un L'Interface De La Classe.

par contre, les classes D'Interface sont plus flexibles Qu'abstraites Classe. C'est parce qu'ils peuvent mettre en œuvre interfaces multiples . Le chose est Java n'a pas d'héritages multiples donc en utilisant abstract les classes ne vous permettront pas d'utiliser une autre structure de hiérarchie de classe...

ainsi, à la fin une bonne règle générale de pouce est: préférez utiliser L'Interface Classes quand il n'y a pas d'implémentations existantes/par défaut dans votre codebase. Et, utilisez des Classes abstraites pour préserver la compatibilité si vous sachez que vous mettrez à jour votre classe à l'avenir."

Bonne chance pour votre prochaine entrevue!

je vais essayer de répondre en utilisant le scénario pratique pour montrer la distinction entre les deux.

Les Interfaces

sont dotées d'une charge utile nulle, c'est-à-dire qu'il n'est pas nécessaire de maintenir un état, et sont donc un meilleur choix pour associer simplement un contrat (capacité) à une classe.

par exemple, disons que j'ai une classe de tâches qui effectue une action, maintenant pour exécuter une tâche dans un thread séparé Je n'ai pas vraiment besoin d'étendre la classe de Thread plutôt un meilleur choix est de faire la tâche implémenter l'interface exécutable (i.e. implémenter sa méthode run ()) et passer ensuite l'objet de cette classe de tâche à une instance Thread et appeler sa méthode start ().

Maintenant, vous pouvez vous demander si Runnable était une classe abstraite?

bien techniquement possible, mais de conception sage qui aurait été un mauvais choix raison étant:

• Runnable n'a aucun état associé avec elle et ni elle "offre" toute implementation par défaut pour la méthode run ()
• tâche devrait l'étendre ainsi il ne pourrait pas étendre une autre classe
• tâche n'a rien à offrir comme spécialisation à la classe Runnable, tout ce dont elle a besoin est de dépasser la méthode run ()

en d'autres termes, la classe de tâche a besoin d'une capacité d'être exécutée dans un thread qu'elle a atteint en mettant en œuvre des vers d'interface exécutables étendant la classe de Thread qui ferait un thread.

il suffit de mettre l'interface us pour définir une capacité (contrat), tout en utilisant un classe abstraite pour définir le squelette (commun/partiel) mise en œuvre de il.

Avertissement: idiot exemple qui suit, essayez de ne pas juger :-P

interface Forgiver {
    void forgive();
}

abstract class GodLike implements Forgiver {
    abstract void forget();
    final void forgive() {
        forget();
    }
}

maintenant, on vous a donné le choix D'être divin, mais vous pouvez choisir D'être Pardonneur seulement (c.-à-d. pas divin) et de faire:

class HumanLike implements Forgiver {
    void forgive() {
       // forgive but remember    
    }
}

Ou vous pouvez choisir d'être semblable à dieu et à faire:

class AngelLike extends GodLike {
    void forget() {
       // forget to forgive     
    }
}

P.S. avec l'interface java 8 peut également avoir des méthodes statiques aussi bien que par défaut (mise en œuvre modifiable) et donc la différence B/W interface et la classe abstraite est encore plus réduite.

presque tout semble être déjà couvert ici.. Ajouter juste un point supplémentaire sur la mise en œuvre pratique de abstract classe:

abstract mot-clé est également utilisé seulement éviter une classe d'être instanciée. Si vous avez une classe concrète qui vous ne voulez pas être instancié - Faire abstract .

votre réponse est correcte, mais je pense qu'il cherchait ce genre de réponse:

la classe Abstraite

• la classe abstraite peut avoir des méthodes abstraites et non abstraites.
• classe Abstraite ne supporte pas l'héritage multiple.
• classe abstraite peut avoir des variables finales, non-finales, statiques et non-statiques.
La classe
• Abstract peut fournir la mise en œuvre de l'interface.

Interface

• Interface peut avoir des méthodes par défaut, statiques et abstraites.
• Interface prend en charge l'héritage multiple.
L'Interface
• n'a que des variables statiques et finales.
• Interface ne peut pas fournir la mise en œuvre de la classe abstraite.

à Partir de ce que je comprends, et comment je m'approche,

Interface est comme une spécification / contrat, toute classe qui met en œuvre une classe d'interface doivent mettre en œuvre toutes les méthodes définies dans la classe abstraite (sauf méthodes par défaut (introduit en java 8))

alors que je définis un résumé de classe quand je connais l'implémentation requise pour certaines méthodes de la classe et certaines méthodes Je ne sais toujours pas ce que sera l'implémentation(nous pourrions savoir la fonction signature mais pas la mise en œuvre). Je le fais pour que plus tard dans la partie du développement quand je sais comment ces méthodes doivent être mises en œuvre, je puisse simplement étendre cette classe abstraite et mettre en œuvre ces méthodes.

Note: Vous ne pouvez pas avoir de corps de fonction dans les méthodes d'interface à moins que la méthode ne soit statique ou par défaut.

je crois que ce que l'intervieweur essayait de faire était probablement la différence entre l'interface et la mise en œuvre.

L'interface - pas d'une interface Java, mais "interface" en termes plus généraux, - un module de code est, fondamentalement, le contrat conclu avec le code client qui utilise l'interface.

l'implémentation d'un module de code est le code interne qui fait fonctionner le module. Souvent, vous pouvez mettre en œuvre une interface particulière dans plus que d'une manière différente, et même de changer la mise en œuvre sans même que le code client soit conscient du changement.

une interface Java ne doit être utilisée qu'en tant qu'interface au sens générique ci-dessus, pour définir comment la classe se comporte au profit du code client en utilisant la classe, sans spécifier Aucune implémentation. Ainsi, une interface inclut les signatures de méthode - les noms, les types de retour et les listes d'arguments - pour les méthodes qui devraient être appelées par le code client, et dans Principe doit avoir beaucoup de Javadoc pour chaque méthode décrivant ce que cette méthode fait. La raison la plus convaincante pour utiliser une interface est si vous prévoyez d'avoir plusieurs implémentations différentes de l'interface, peut-être en choisissant une implémentation en fonction de la configuration de déploiement.

une classe abstraite Java, en revanche, fournit une implémentation partielle de la classe, plutôt que d'avoir un but principal de spécifier une interface. Il doit être utilisé lorsque plusieurs classes partagent le code, mais lorsque les sous-classes sont également censées fournir une partie de la mise en œuvre. Cela permet au code partagé d'apparaître en un seul endroit - la classe abstraite - tout en précisant que certaines parties de la mise en œuvre ne sont pas présentes dans la classe abstraite et devraient être fournies par des sous-classes.

votre réponse est correcte, mais l'intervieweur a besoin de vous pour différencier selon la perspective de l'ingénierie logicielle pas selon les détails de Java.

mots simples:

une Interface est comme l'interface d'un magasin tout ce qui est montré sur elle devrait être là dans le magasin, donc toute méthode dans l'Interface doit être là mis en œuvre dans la classe de béton. Maintenant, si certaines classes de partager certaines méthodes exactes et varie dans d'autres. Supposer L'Interface est à propos d'un magasin qui contient deux choses et supposons que nous avons deux magasins à la fois contiennent de l'équipement de sport, mais l'un a vêtements supplémentaires et l'autre a Chaussures supplémentaires. Donc, ce que vous faites est de faire une classe abstraite pour le Sport qui met en œuvre la méthode sportive et de laisser l'autre méthode non appliquée. Classe abstraite ici signifie que ce magasin n'existe pas lui-même mais il est la base pour d'autres classes/magasins. De cette façon, vous organisez le code, en évitant les erreurs de réplication du code, en unifiant le code, et d'assurer la réutilisation par une autre classe.