de l'Interface de la Vie Réelle analogie:

disons que vous voulez sortir un livre de la bibliothèque. Ce que vous ferez:

1) aller à la bibliothèque

2) trouvez le livre qui vous intéresse

3) sélectionner le livre

4) allez au Bureau des bibliothécaires pour leur demander de publier le livre.

maintenant ici bibliothécaire est une Interface, ce qui signifie que vous n'êtes pas intéressé par qui l'enfer est bibliothécaire, vous êtes seulement intéressé par cette personne assise sur le bureau de bibliothécaire (est la personne qui a accepté un contrat pour agir en tant que bibliothécaire, ce qui signifie que cette personne a accepté de mettre en œuvre tous les comportements de bibliothécaire)

Alors, laissez dire : le Comportement de Bibliothécaire sont:

1) Question livre

2) Livre De Réémission

3) Livre De Retour.

la personne qui est désignée comme bibliothécaire (ce qui signifie convenu d'adapter les trois comportements ci-dessus), doit mettre en œuvre les comportements à sa propre façon.

disons que PersonA veut jouer un rôle de bibliothécaire, alors il a besoin d'adapter les 3 comportements ci-dessus. En tant que Client, nous ne nous soucions pas de la façon dont il exécute ses comportements de bibliothécaire, nous sommes seulement intéressé par cette personA est bibliothécaire et il demeure pour effectuer les tâches de bibliothécaire.

Par conséquent, ce que vous allez faire, est de référence par Interface[aller au Bureau du bibliothécaire (qui vous mènera à des personnes agissant en tant que bibliothécaire)] et disons à L'avenir une personne a quitté le poste de bibliothécaire, puis en tant que client , vous ne serez pas affecté si vous avez approché le "Bureau du bibliothécaire , au lieu de personne spécifique agissant comme bibliothécaire .So code to Interface au lieu de Concret est bénéfique.

class PersonA implements Librarian {
    public void IssueBook(){...}
    public void ReIssueBook(){...}
    public void ReturnBook(){...}

    //Other person related tasks...
}   

même en tant qu'un seul développeur, les interfaces peuvent être un outil très utile. Laissez-moi illustrer avec un exemple.

supposons que vous développiez un système pour gérer un catalogue de bibliothèque et la bibliothèque prêtera des livres et des DVD. Vous décidez de créer des classes Livre et Dvd pour modéliser les articles prêtés, mais maintenant vous voulez mettre en œuvre le polymorphisme de sorte que vous pouvez traiter avec des articles plutôt que des livres ou des DVD. Question est-ce que élément devrait être une classe abstraite ou une Interface ?

dans ce cas, vous voulez probablement utiliser une classe abstraite car il y a des fonctionnalités communes à la fois Livre et Dvd que vous pouvez fournir par une classe mère, par exemple vérifier ou retourner un élément.

maintenant, disons que vous voulez mettre en œuvre un mécanisme de persistance pour votre catalogue de bibliothèque. Vous avez décidé que vous souhaitez stocker des données dans une base de données, certaines données dans des fichiers XML et des données dans les fichiers délimités par des virgules. La question est donc maintenant de savoir comment vous pouvez procéder de manière polymorphe pour gérer une API de persistance générale ?

dans ce cas, vous devriez probablement définir une Interface qui peut être implémentée par chacune de vos classes fournissant la base de données, XML et la persistance délimitée par la virgule puisque chacun de ces mécanismes de persistance fournit des caractéristiques similaires: le stockage et la récupération des données, mais chacun sera mis en œuvre très différemment. Cela vous permettra de changer facilement le mécanisme de persistance que vous utilisez sans avoir à faire beaucoup de changements au code qui utilise le mécanisme de persistance.

aident à clarifier la distinction entre les différentes unités fonctionnelles. Une unité dépend d'une autre unité à faire quelque chose, pas à être quelque chose. Aussi longtemps que cet autre peut faire ce qui est stipulé dans l'interface (penser contrat ), alors il peut 151920920" être quelque chose derrière les scènes.

par exemple, j'ai un processeur d'entrée qui lit les entrées d'un endroit, et les écrit à un autre endroit. Il ne se soucie pas de quoi/ où, ou à quoi/où. Tout ce qui compte, c'est qu'il obtienne l'entrée d'un certain type de lecteur (en utilisant l'interface IReader ) d'un seul côté, et la remet à un certain type d'auteur (en utilisant l'interface IWriter ).

dans mon premier mise en œuvre, le IReader implementer obtient des trucs à partir d'une base de données SQL, et le IWriter implementer le poste via un client de service web. Cependant, nous finirons par créer d'autres implémenteurs à chaque extrémité pour accéder à d'autres dépôts (sites FTP, répertoires de fichiers sur un lecteur réseau local, etc.).).

pendant tout ce temps, le processeur du milieu s'en fiche et ne change pas. Il parle juste à travers ces normes interface.

théoriquement, vous pourriez utiliser une classe de base (de préférence une abstract one) au lieu d'une interface, mais cela commence à verrouiller vos modules plus étroitement ensemble, ce qui rend votre système plus difficile à maintenir. Perdre le couplage rend vraiment votre vie plus facile, même si vous n'êtes pas sur une équipe de programmeurs. Considérez-vous comme un programmeur différent, chaque fois que vous travaillez sur une partie différente de votre système. Chaque fois que vous revisitez un section, vous devez réapprendre ce qu'il fait pour l'entretenir. Si chaque pièce de votre système est étroitement liée à chaque autre pièce, alors vous devez avoir une connaissance constante et intime de l'ensemble du système, pas seulement la pièce sur laquelle vous travaillez.

il y a aussi le concept d'une classe unique qui implémente des interfaces multiples, ce qui est presque comme un héritage multiple. Dans cette situation, une seule classe peut effectuer plusieurs travaux (qui peut être soutenu n'est pas très judicieux, mais au moins, c'est possible). Si vous avez choisi d'utiliser une classe de base au lieu d'une interface ci-dessus, alors ce ne serait pas possible.

à première vue, les classes abstraites et les interfaces semblent être une évidence. Pourquoi ne fournir qu'une interface alors que vous pouvez également fournir une implémentation de base? Après enquête, vous verrez qu'il y a autre chose.

cela dit, il y a un certain nombre de raisons d'utiliser des interfaces. Vous pouvez trouver un billet de blog décent sur les différences ici .

cela dit, considérez le fait que vous pouvez créer une interface (une "contrat" qui dit que votre classe supporte certainement certains calls/method signature invocations), mais vous ne pouvez fournir qu'une seule classe abstraite. Aussi considérer le fait que vous pouvez créer une classe abstraite qui implémente une ou plusieurs interfaces, et héritent de ce. Ce n'est pas un bord de cas. C'est effectivement assez fréquemment dans l'API pour haute extensibilité.

découvrez le blog je vous ai cité et vous devriez obtenir une compréhension approfondie de quand pour utiliser chacun et pourquoi vous les utiliseriez. Je recommande aussi fortement un bon livre tel que "CLR via C#" de Microsoft Press. Vous en apprendrez beaucoup!

la raison pour laquelle il existe des interfaces est due aux 2 concepts principaux de L'OOP, qui est "Identité" et" fonctionnalité

ont une fonctionnalité et une identité. Avec l'héritage, les objets instanciés peuvent avoir beaucoup de fonctionnalités et de multiples identités.

sont une identité sans fonctionnalité. La fonctionnalité sera fournie par la classe instanciated.

La troisième forme, un "mixin" est fonctionnalité sans identité. Les langages de programmation comme ruby fournissent cette troisième forme d'héritage.

la façon dont vous utilisez une interface diffère selon le contexte de votre langage de programmation et vos circonstances, mais rappelez-vous simplement que les interfaces sont utilisées pour définir des identités qui sont imposées sur des objets.

pour ajouter aux réponses précédentes, les interfaces vous aident lors des tests unitaires en vous permettant d'injecter un objet simulé basé sur une interface dans votre code, en vous permettant de simuler des scénarios spécifiques et aussi d'isoler votre test d'unité à un composant spécifique sans compter sur des composants externes.

par exemple, supposons que vous ayez une classe de logique d'entreprise qui utilise une classe de logique de données pour extraire des données d'une source de données et ensuite les traiter. En créant une interface pour la classe de logique de données qu'il hérite alors, vous pourriez créer une instance simulée/simulée de cette classe basée sur l'interface et l'injecter dans la classe de logique d'affaires que vous testez à l'unité. L'instance moquée peut être définie de manière à s'attendre à certains appels de méthode/propriété, à des exceptions de lancer à certains points, à des sorties valides de retour etc. Cela signifie que vos tests unitaires peuvent être effectués plus rapidement/potentiellement de manière plus fiable car ils ne dépendent pas de la source de données sous-jacente étant disponible / ne pas avoir réellement à se connecter à elle. Et vous isolez le test de l'unité jusqu'à une unité de code spécifique.

Une interface est mieux qu'une classe abstraite parce que vous pouvez implémenter plusieurs interfaces, et vous ne pouvez hériter d'une classe abstraite.

donc vous pouvez faire:

class MyRow extends AbstractRow implements ISearchable, ISortable
{

}

aussi, rechercher StackOverflow pour d'autres questions similaires comme besoin d'interfaces dans c#

et les classes abstraites servent à des fins différentes. Pour commencer, une classe abstraite n'est bonne qu'à hériter de - elle ne peut pas être instanciée directement. Vous pouvez mettre du code d'implémentation dans une classe abstraite, mais ce code ne peut être appelé que de la classe qui l'étend, ou à travers la classe qui l'étend.

exemple:

public abstract class A {
    public void myFunc() {
        //do some work
    }
}

public class B : A {
    private void someOtherFunc() {
        base.myFunc();
    }
}

public class Z {
    public void exampleFunc() {
        //call public base class function exposed through extending class:
        B myB = new B();
        myB.myFunc();

        //explicitly cast B to A:
        ((A) myB).myFunc();

        //'A' cannot be created directly, do implicit cast down to base class:
        A myA = new B();
        myA.myFunc();
    }
}

le but d'une interface est de fournir un contrat - ce désigne la classe qui l'implémente a pour fournir l'implémentation des propriétés ou des fonctions déclarées dans l'interface, et il doit utiliser les signatures de fonction exactes. Cela fournit une garantie quand j'écris un code qui appelle une classe qui implémente une interface, et il est hors de propos ce que les classes sont dérivées, ou même dans quelle langue ils sont écrits, ou d'où je les ai obtenus. Une autre fonctionnalité intéressante est que je peux avoir plusieurs implémentations différentes de la même signature de fonction pour différentes interfaces. Vérifiez cet exemple, qui utilise certaines des mêmes classes de l'échantillon précédent:

public class Z {
    public void exampleFunc() {
        C myC = new C();
        //these two calls both call the same function:
        myC.myFunc();
        ((IExampleInterface1)myC).myFunc();

        D myD = new D();
        //hmmm... try and work out what happens here, which myFunc() gets called?
        //(clue: check the base class)
        myD.myFunc();

        //call different myFunc() in same class with identical signatures:
        ((IExampleInterface1)myD).myFunc();
        ((IExampleInterface2)myD).myFunc();
    }
}

interface IExampleInterface1
{
    void myFunc();
}

interface IExampleInterface2
{
    void myFunc();
}

public class C : IExampleInterface1
{
    public void myFunc()
    {
        //do stuff
    }
}

public class D : A, IExampleInterface1, IExampleInterface2
{
    void IExampleInterface1.myFunc()
    {
        //this is called when D is cast as IExampleInterface1
    }

    void IExampleInterface2.myFunc()
    {
        //this is called when D is cast as IExampleInterface2
    }
}

c'est un problème de design (je parle de java world).

l'interface vous permet de définir le comportement et la structure du composant (classe) de votre logiciel sans vous donner de contrainte à l'exécution.

la classe abstraite, à la place, vous donne un comportement par défaut pour une méthode: utile si vous êtes sûr que ce code pourrait ne pas changer dans le temps de lyfe de l'application.

exemple:

vous avez une web application du système commercial envoyer un email dans certaines situation (signe d'un nouvel utilisateur).

vous pouvez utiliser la classe abstraite SenderCommunication avec la méthode boolean sendWithSuccefull(...) si vous êtes sûr que le comportement ne changera souvent.

vous pouvez utiliser l'interface InterfaceSenderCommunication avec la méthode boolean sendWithSuccefull(...) si vous n'êtes pas sûr que l' le comportement ne changera souvent.

bien sûr, le jugement de "changer souvent pas souvent" dépend de 2 éléments:

• Combien de temps je doit passé pour la synchronisation l'ancien code avec les nouvelles spécifications?
• Combien le client paie? ;)

supposons que j'ai un établissement alimentaire de classe, maintenant je veux faire une opération simple et crude, alors comment je fais? J'ai défini une interface pour le service, mais pourquoi?

public interface IFoodEstablishmentService
{
    Task<int> AddAsync(FoodEstablishment oFoodEstablishment);
    FoodEstablishment SelectByFoodEstablishmentId(long id);
    Task<int> UpdateAsync(FoodEstablishment oFoodEstablishment);
    Task<int> DeleteAsync(FoodEstablishment oFoodEstablishment);
}

puis je mettrai en œuvre ce Contrat ou cette interface pour ce service particulier

public class FoodEstablishmentService : IFoodEstablishmentService
{
    public async Task<int> AddAsync(FoodEstablishment oFoodEstablishment)
    {
       // Insert Operation
        return result;
    }

    public FoodEstablishment SelectByFoodEstablishmentId(long id)
    {
        // Select Logic
        return oFoodEstablishment;
    }

    public async Task<int> UpdateAsync(FoodEstablishment oFoodEstablishment)
    {
        // Update Logic
        return result;
    }

    public async Task<int> DeleteAsync(FoodEstablishment oFoodEstablishment)
    {
        // Delete Logic
        return result;
    }

}

ainsi dans mon programme principal ou où je souhaite utiliser le Service, je ferai

IFoodEstablishmentService oFoodEstablishmentService =  new FoodEstablishmentService();
FoodEstablishment oFoodEstablishment = // Input might be from views;
oFoodEstablishmentService.AddAsync(oFoodEstablishment);

jusqu'à maintenant, il semble comme une étape supplémentaire, nous pourrions directement fait 1519110920"

FoodEstablishmentService oFoodEstablishmentService =  new FoodEstablishmentService();
FoodEstablishment oFoodEstablishment = // Input might be from views;
oFoodEstablishmentService.AddAsync(oFoodEstablishment);

mais attendez ce que si je pourrais avoir besoin de passer ma logique d'insertion par la file d'attente plutôt que directement au serveur, attendre l'opération d'insertion pour compléter et ensuite retourner le résultat, plutôt passer sur la file d'attente et puis le travailleur de file d'attente gère cette opération, pourrait ne pas être la meilleure idée d'insérer la file d'attente, mais oui certainement bon pour l'interface exemple :-). Donc maintenant ce que je fais est, créer un autre établissement alimentaire de classe mettant en œuvre même contrat iFood establishment.

public class FoodEstablishmentQueueService : IFoodEstablishmentService
{
    public async Task<int> AddAsync(FoodEstablishment oFoodEstablishment)
    {
       // Insert Queue Operation
        return result;
    }

    public FoodEstablishment SelectByFoodEstablishmentId(long id)
    {
        // Select Queue Logic
        return oFoodEstablishment;
    }

    public async Task<int> UpdateAsync(FoodEstablishment oFoodEstablishment)
    {
        // Update Queue Logic
        return result;
    }

    public async Task<int> DeleteAsync(FoodEstablishment oFoodEstablishment)
    {
        // Delete Queue Logic
        return result;
    }
}

donc maintenant si je veux utiliser la version file d'attente, je ferais juste

IFoodEstablishmentService oFoodEstablishmentService =  new FoodEstablishmentQueueService();
FoodEstablishment oFoodEstablishment = // Input might be from views;
oFoodEstablishmentService.AddAsync(oFoodEstablishment);

nous pourrions faire cela avec l'ancienne façon en utilisant class mais qui limite l'instanciation de classe avec une classe particulière qui est un peu rigide à l'extension, maintenant Foodsinstitumentqueueservice peut faire d'autres choses aussi, créer une autre méthode jusqu'à ce que le contrat est valide donc interface est contact pour la cohérence, L'imagerie d'un gars faire la version normale et d'autres en faisant la version de file d'attente ou quelqu'un qui fait la version de cache, il pourrait y avoir des problèmes concernant la signature à moins que son pré-spécifié sur le contrat de travail et les gens ne finissent pas par tout vérifier.

de même, considérons un autre exemple simple d'utilisation de types prédéfinis comme IEnumerable. Supposons que je passe une liste de la collecte de L'établissement alimentaire et le retour personnalisé trié liste

public FoodEstablishment[] SortFoodEstablishment(FoodEstablishment[] list)
{
    foreach(var oFoodEstablishment in list)
    {
    // some logic
    }
    return sortedList;
}

donc nous l'utiliserons de cette façon

FoodEstablishment[] list = new FoodEstablishment[]{ //some values }
var listSorted = oFoodEstablishmentService.SortFoodEstablishment(list);

mais que faire si nous envoyons list au lieu de array

List<FoodEstablishment> list = //some values;
var listSorted = oFoodEstablishmentService.SortFoodEstablishment(list);

nous allons avoir une erreur, parce que son implémentation stricte en utilisant la classe donc à la place nous utilisons IEnumerable<> qui est implémenté par la liste et qui supprime fondamentalement la dépendance de la liste à L'Interface

public IEnumerable<FoodEstablishment> SortFoodEstablishment(IEnumerable<FoodEstablishment> list)
{
    foreach(var oFoodEstablishment in list)
    {
    // some logic
    }
    return sortedList;
}

Donc en général de mise en œuvre extrêmement dépend de la situation

L'une des raisons d'utiliser des interfaces est quand une classe implémente un certain nombre d'interfaces. Une classe abstraite ne peut pas faire ça.

un exemple est une classe qui gère le mouvement de la souris et les presses à clés vont implémenter les interfaces IMouseMove et IKeyPress.

également, l'utilisation d'interfaces facilite le test de l'unité. Afin de tester les classes qui dépendent des interfaces, et aussi longtemps que vous utilisez une sorte d'injection de dépendance, vous pouvez créer des classes qui implémentent les interfaces dépendantes, ou vous pouvez utiliser un moteur de moquerie.

Java lang ne supporte pas les héritages multiples car les interfaces sont utilisées pour atteindre le but.

pour qu'une classe soit abstraite, une seule méthode doit être abstraite ; interface toutes les méthodes sont abstraites .

classe Abstraite v/s de l'interface est toujours un point de discussion entre développeurs. J'ajouterais mes 5 cents. Utilisez la classe abstract lorsque vous voulez étendre une base comman et où vous voulez fournir une implémentation par défaut à la méthode abstract.

utiliser l'interface quand vous voulez appliquer exactement toutes les méthodes abstraites à la classe implémenter l'interface et aucun corps par défaut à une méthode ne peut être fourni.

Il est de bon style pour stocker une référence à un HashSet ou TreeSet dans une variable de type Ensemble.

Set<String> names = new HashSet<String>();

de cette façon, vous devez changer une seule ligne si vous décidez d'utiliser un TreeSet à la place.

en outre, les méthodes qui fonctionnent sur des ensembles doivent spécifier les paramètres de type ensemble:

public static void print(Set<String> s)

alors la méthode peut être utilisée pour toutes les implémentations.

En théorie, nous devrions faire la même recommandation pour les listes liées, à savoir sauver des Les références de liste de liens dans les variables de liste de type. Cependant, dans la bibliothèque Java, L'interface List est commune aux classes ArrayList et LinkedList . En particulier, il dispose de méthodes get et set pour l'accès aléatoire, même si ces méthodes sont très inefficaces pour les listes liées.

vous ne pouvez pas écrire de code efficace si vous ne savez pas si l'accès aléatoire est efficace ou pas. Il s'agit clairement d'une grave erreur de conception dans la bibliothèque standard, et je ne peux pas recommander l'utilisation l'interface de liste pour cette raison.

(pour voir à quel point cette erreur est embarrassante, regardez le code source pour la méthode binarySearch de la classe Collections. Cette méthode nécessite Liste paramètre, mais la recherche binaire n'a pas de sens pour une liste liée. Le code ensuite maladroitement essaie de découvrir si la liste est une liste chaînée, et passe ensuite à une la recherche linéaire!)

l'interface Set et l'interface Map , sont bien conçues, et vous devriez les utiliser.

Interface garde la définition et la mise en œuvre séparées.Donc, si vous voulez une implémentation spécifique à un fournisseur, alors c'est la meilleure façon de le faire .

L'exemple de la vraie vie de ceci est JDBC si vous voyez L'API Statemnet ,PreparedStatemnet tout est interface mais l'implémentation est spécifique au fournisseur comme Oracle ojdbc jar a une autre implémentation ,mysql avait une autre.

dans le cas où vous voulez changer la base de données vous venez il faut modifier le nom du pilote dans la classe connection. C'est l'avantage d'utiliser l'interface

utilisations de l'interface:

1. pour définir un contrat
2. pour relier des classes sans rapport avec a un capacités (par exemple, les classes mettant en œuvre l'interface sérialisable peuvent avoir ou ne peuvent pas avoir de relation entre elles sauf la mise en œuvre de cette interface
3. pour assurer l'interchangeabilité mise en oeuvre, p. ex. Strategy_pattern

si vous cherchez java comme langage de programmation, interface a peu de capacités supplémentaires avec l'ajout des méthodes default et static depuis la version Java-8.

référez-vous à cette question pour plus de détails:

Pourquoi utiliser des Interfaces, héritage Multiple vs Interfaces, avantages des Interfaces?

les objets qui appartiennent à une catégorie peuvent utiliser une Interface.Quand EST-il existe UNE relation entre les objets.

E. G. Texte, Image, MP3 ,FLV,MOV belongs FileType category

si notre application permet aux utilisateurs de télécharger 4 types de fichiers, ils appartiennent tous à une catégorie appelée type de fichier

1. Texte
2. Image
3. Audio
4. Vidéo

code intérieur nous aurions l'objet pour chacun des types ci-dessus.

supposons que nous devons envoyer un fichier alors

de sorte que nous pouvons supposer que tous les types de fichiers(texte,Audio, etc.) sont de type FileFormat.Alors on forme une sorte de relation.

cela aide en retournant le type de données simple au lieu de retourner le type spécifique à partir d'une fonction nous pouvons envoyer le type commun qui est FileFormat.