Pourquoi utilisons-nous Interface? Est-ce seulement pour la normalisation?
Pourquoi utilisons-nous Interface?
Est-ce seulement pour la normalisation?
Buts des interfaces
- créer des logiciels faiblement couplés
- support design by contract (un réalisateur doit fournir l'interface complète)
- permettre un logiciel enfichable
- permettre à différents objets d'interagir facilement
- masquer les détails d'implémentation des classes les uns aux autres
- faciliter la réutilisation des logiciels
Analogie 1: À l’instar de la navette spatiale américaine, les vaisseaux spatiaux russe Soyouz et chinois Shenzhou 5 peuvent tous s’arrimer à la Station spatiale internationale, car ils implémentent la même interface d’arrimage. (Ceci est juste un exemple - je ne sais pas si c'est vrai dans la vie réelle mais suspendons notre incrédulité pour l'exemple)
Analogie 2: Comme vous pouvez brancher divers écrans d’ordinateur à votre ordinateur à la maison. Vous pouvez y brancher un téléviseur mural, un vieux tube cathodique (type épais), un écran plat 20 "ou une machine braille permettant aux aveugles de" voir "au toucher. Il existe une compatibilité entre ces divers appareils et vos ordinateur parce qu'ils sont tous d'accord sur les normes d'interface.
Détails des interfaces C # -- Avec les interfaces C #/OOP, vous faites le même genre de chose, mais dans le monde invisible/virtuel.
Vous avez raison sur standardisation, mais aussi souplesse, évolutivité, extensibilité, maintenabilité, réutilisabilité, testabilité et Puissance.
(Plus vous utiliserez des interfaces logicielles, plus ces "mots à la mode" seront compris. Et considérez toujours les interfaces dans le monde réel car elles nous ont été tout aussi efficaces.)
Une interface est utilisée pour décrire ce qu'une chose implémentée peut faire. Vous avez donc la possibilité de traiter plusieurs objets implémentant la même interface comme un type de cette interface.
Par exemple:
public interface IMyInterface{
public void DoFirst();
public int DoSecond();
}
public class A : IMyInterface{
//class has to implement DoFirst and DoSecond
public void DoFirst(){
Console.WriteLine("Blubb1");
}
public int DoSecond(){
Console.WriteLine("Blubb2");
return 2;
}
}
public class B : IMyInterface{
//class has to implement DoFirst and DoSecond
public void DoFirst(){
Console.WriteLine("Blibb1");
}
public int DoSecond(){
Console.WriteLine("Blibb2");
return 4;
}
}
Les classes implémentent l'interface de plusieurs manières. Mais vous pouvez les utiliser comme IMyInterface . Par exemple:
public static void DoMethodsInInterface(IMyInterface inter){
inter.DoFirst();
inter.DoSecond();
}
public static void main(){
DoMethodsInInterface(new A());
DoMethodsInInterface(new B());
//Or use it in a List
List<IMyInterface> interlist = new List<IMyInterface>();
interlist.Add(new A());
interlist.Add(new B());
foreach(IMyInterface inter in interlist){
inter.DoFirst();
}
}
J'espère que cela explique un peu pourquoi les interfaces sont utiles.
C’est pour l’interface :), afin que vous puissiez vous connecter entre vous, c’est utile quand vous avez
- plusieurs implémentations de la même chose
- lorsque vous appliquez une interface à plusieurs classes différentes parce que vous avez besoin d'une sorte de convention voulant que ces classes puissent faire des choses ou avoir des fonctionnalités
Voici la vue de haut niveau ...
Les interfaces jouent un grand rôle dans le concept de masquage d'informations .
En gros, ils vous aident à masquer les détails de l’implémentation de votre classe afin qu’une classe appelante ne dépende pas de cette implémentation. Par conséquent, en utilisant des interfaces, vous pouvez modifier l'implémentation sans changer la classe d'appel. Tout cela à tour de rôle limite la complexité de votre code et le rend plus facile à gérer à long terme.
Lorsque j'ai commencé à comprendre les interfaces, elles m'ont été présentées comme un "contrat qui décrit votre classe". Je ne sais pas si cela vous aidera, mais si vous pensez à une interface pour une voiture, vous pourriez dire que celle-ci entraîne , une rupture , et tourne . Donc, tant que cela me mène du point A au point B, je n'ai pas vraiment besoin de savoir comment ces fonctions sont mises en œuvre.
Les interfaces sont quelque peu gênantes . Elles supportent la conception par contrat simplement en croyant que le même nom et l'interface implémentée impliquent le même comportement. Cela ne fonctionne que grâce à la documentation de l'API, il doit être vérifié par l'homme. Cela rend les interfaces trop faibles. Une façon de contourner ce problème pourrait être des spécifications formelles… .. D'autre part, les interfaces sont trop fortes, trop strictes. Vous ne pouvez pas faire évoluer des interfaces qui gênent souvent la réutilisation. Cela est résolu par des protocoles - mécanisme dans les langages dynamiques, qui envoient des messages (méthodes d'appel) et lorsque ce message n'est pas pris en charge par le destinataire, le rappel standard est appelé . Il serait préférable d'avoir des protocoles concrets avec des contraintes.
La principale raison pour laquelle les interfaces sont utilisées dans des langages tels que C #/Java est que ces langages ne prennent pas en charge l'héritage multiple (classe) (voir Quel est le problème exact de l'héritage multiple? ).
Mais l'implémentation multiple (interface) est permise, ce qui permet aux classes d'être utilisées de différentes manières.
Pensez remoting ...
Il y a un client et un serveur impliqués ici. Disons qu'ils sont physiquement séparés par Internet. Le client appelle une méthode dont l'exécution réelle se produit sur le serveur. Du point de vue du client, le client ne sait rien de l'objet du serveur qui exécute l'exécution. Cependant, il sait quelle méthode appeler. Car lors de la construction du programme client, nous ne sommes exposés qu'à une interface (ou un contrat). Nous ne sommes pas exposés à l'objet entier qui vit actuellement sur le serveur. Essayez de faire des applications de démonstration dans .net remoting, et vous comprendrez le reste. Bonne programmation.
Interface fournit un prototype modal contenant uniquement la déclaration de fonctionnalité d’un comportement spécifique.
et si vous voulez implémenter ce comportement dans la classe, vous devez implémenter cette interface dans la classe, alors la classe possède cette fonctionnalité de comportement ou elle peut avoir plusieurs comportements.
parce que la classe peut implémenter plusieurs interfaces.
Vous trouverez ci-dessous les principales raisons d’utiliser des interfaces.
- Extensibilité
- Mise en œuvre cachée
- Accéder à un objet via des interfaces
- Couplage lâche.
veuillez visiter ce lien pour en savoir plus sur les interfaces avec un exemple de code téléchargeable
Si quelqu'un d'autre est comme moi et apprend par l'exemple et en faisant, plutôt que par des explications, voici du code ...
J'ai trouvé cette implémentation d'un réseau de neurones en C #, y compris le téléchargement de projet, qui utilise les interfaces de manière élégante et utile:
En commençant par une interface, vous pouvez implémenter un proxy , permettant ainsi un chargement ou des vérifications paresseux lors de l’appel des méthodes d’une implémentation concrète.
Pourquoi utilisons-nous des interfaces?
Certaines langues implémentent des appels de méthodes polymorphes à l'aide de vtables et rejettent la plupart des informations de type, ce qui rend difficile pas la définition d'interfaces.
Donc, parfois, nous utilisons simplement des interfaces parce que la conception du langage le requiert.
L'interface sépare le type de données de la logique d'implémentation.