Quelle est la définition de "interface" dans la programmation orientée objet
Ok, un de mes amis va et vient sur ce que "interface" signifie dans la programmation.
Quelle est la meilleure description d'une "interface".
Pour moi, une interface est un modèle de classe. Est-ce la meilleure définition?
Une interface est l’un des termes les plus surchargés et les plus déroutants du développement.
C'est en fait un concept d'abstraction et d'encapsulation. Pour une "boîte" donnée, il déclare les "entrées" et "sorties" de cette boîte. Dans le monde des logiciels, cela signifie généralement les opérations pouvant être invoquées sur la boîte (avec les arguments) et, dans certains cas, les types de retour de ces opérations.
Ce qu’elle ne fait pas, c’est qu’elle ne définit pas la sémantique de ces opérations, bien qu’il soit courant (et très bonne pratique) de les documenter à proximité de la déclaration (par exemple, via des commentaires) ou de choisir de bonnes conventions de dénomination. . Néanmoins, rien ne garantit que ces intentions seront suivies.
Voici une analogie: jetez un coup d'œil sur votre téléviseur lorsqu'il est éteint. Son interface est composée des boutons qu’elle contient, des divers connecteurs et de l’écran. Sa sémantique et son comportement font qu’il prend des entrées (par exemple, la programmation par câble) et comporte des sorties (affichage à l’écran, son, etc.). Cependant, lorsque vous regardez un téléviseur qui n'est pas branché, vous projetez la sémantique attendue dans une interface. Tout ce que vous savez, le téléviseur pourrait simplement exploser lorsque vous le branchez. Cependant, en fonction de son "interface", vous pouvez supposer qu'il ne produira pas de café car il n'a pas de prise d'eau.
En programmation orientée objet, une interface définit généralement l'ensemble des méthodes (ou messages) auxquelles une instance d'une classe disposant de cette interface pourrait répondre.
Ce qui ajoute à la confusion, c’est que dans certains langages, comme Java, il existe une interface avec sa sémantique spécifique au langage. En Java, par exemple, il s’agit d’un ensemble de déclarations de méthodes, sans implémentation, mais une interface correspond également à un type et obéit à diverses règles de typage.
Dans d'autres langages, comme le C++, vous n'avez pas d'interface. Une classe elle-même définit des méthodes, mais vous pouvez considérer l'interface de la classe comme les déclarations des méthodes non privées. En raison de la compilation de C++, vous obtenez des fichiers d'en-tête dans lesquels vous pourriez avoir "l'interface" de la classe sans implémentation réelle. Vous pouvez également imiter les interfaces Java avec des classes abstraites avec des fonctions virtuelles pures, etc.
Une interface n'est certainement pas un modèle pour une classe. Un schéma, par définition, est un "plan d'action détaillé". Une interface ne promet rien sur une action! La source de confusion est que dans la plupart des langages, si vous avez un type d’interface qui définit un ensemble de méthodes, la classe qui l’implémente "répète" les mêmes méthodes (mais fournit la définition), de sorte que l’interface ressemble à un squelette ou à une aperçu de la classe.
Considérez la situation suivante:
Vous êtes au milieu d'une grande pièce vide lorsqu'un zombie vous attaque soudainement.
Tu n'as pas d'arme.
Heureusement, un autre être humain vivant se tient à la porte de la pièce.
"Rapide!" vous lui criez dessus. "Jette-moi quelque chose avec lequel je peux toucher le zombie!"
Considérons maintenant:
Vous n'avez pas précisé (et vous ne vous en souciez pas) exactement quoi votre ami choisira de lancer;
... Mais cela n'a pas d'importance, à condition que:
C'est quelque chose qui peut être jeté (il ne peut pas vous jeter le canapé)
C'est quelque chose que vous pouvez saisir (Espérons qu'il n'a pas lancé de shuriken)
C'est quelque chose que vous pouvez utiliser pour frapper le cerveau du zombie (Cela exclut les oreillers et autres)
Peu importe que vous obteniez une batte de baseball ou un marteau -
tant qu'il met en œuvre vos trois conditions, vous êtes bon.
Résumer:
Lorsque vous écrivez une interface, vous dites essentiellement: "J'ai besoin de quelque chose qui ..."
L'interface est un contrat auquel vous devez vous conformer ou être donné, selon que vous soyez un réalisateur ou un utilisateur.
Je ne pense pas que "blueprint" soit un bon mot à utiliser. Un plan vous indique comment construire quelque chose. Une interface évite spécifiquement de vous dire comment construire quelque chose.
Une interface définit comment vous pouvez interagir avec une classe, c’est-à-dire les méthodes qu’elle supporte.
Pour moi, une interface est un modèle de classe. Est-ce la meilleure définition?
Non, un plan comprend généralement les éléments internes. Mais une interface concerne uniquement ce qui est visible à l'extérieur d'une classe ... ou plus précisément, une famille de classes qui implémentent l'interface.
L'interface comprend les signatures des méthodes et des valeurs des constantes, ainsi qu'un "contrat de comportement" (généralement informel) entre les classes qui implémentent l'interface et les autres qui l'utilisent.
En Programmation, une interface définit le comportement d'un objet, mais ne spécifie pas le comportement. C'est un contrat qui garantira qu'une certaine classe peut faire quelque chose.
Considérez ce morceau de code C # ici:
using System;
public interface IGenerate
{
int Generate();
}
// Dependencies
public class KnownNumber : IGenerate
{
public int Generate()
{
return 5;
}
}
public class SecretNumber : IGenerate
{
public int Generate()
{
return new Random().Next(0, 10);
}
}
// What you care about
class Game
{
public Game(IGenerate generator)
{
Console.WriteLine(generator.Generate())
}
}
new Game(new SecretNumber());
new Game(new KnownNumber());
La classe Game requiert un numéro secret. Afin de le tester, vous voudriez injecter ce qui sera utilisé comme un nombre secret (ce principe s'appelle Inversion of Control).
La classe de jeu veut être "ouverte d'esprit" sur ce qui va réellement créer le nombre aléatoire, elle demandera donc dans son constructeur "tout ce qui a une méthode Generate".
Tout d'abord, l'interface spécifie les opérations qu'un objet fournira. Il contient juste à quoi ça ressemble, mais aucune implémentation réelle n'est donnée. Ceci est juste la signature de la méthode. Classiquement, les interfaces en C # sont précédées du préfixe I . Les classes implémentent désormais IGenerate Interface. Cela signifie que le compilateur s'assurera qu'ils ont tous deux une méthode, qui renvoie un int et s'appelle Generate. On appelle maintenant le jeu deux objets différents, chacun implémentant l'interface correcte. D'autres classes produiraient une erreur lors de la construction du code.
Ici, j'ai remarqué l'analogie de plan que vous avez utilisée:
Une classe est généralement considérée comme un modèle pour un objet. Une interface spécifie quelque chose qu'une classe devra faire, alors on pourrait argumenter qu'il ne s'agit en fait que d'un plan pour une classe, mais comme une classe n'a pas nécessairement besoin d'une interface, je dirais que cette métaphore est en train de se transformer. Pensez à une interface comme un contrat. La classe qui "le signe" sera légalement obligée (forcée par la police du compilateur) de respecter les termes et les conditions du contrat. Cela signifie qu'il devra faire ce qui est spécifié dans l'interface.
Tout cela est dû à la nature typée statiquement de certains langages OO, comme c'est le cas avec Java ou C #. En revanche, en Python, un autre mécanisme est utilisé:
import random
# Dependencies
class KnownNumber(object):
def generate(self):
return 5
class SecretNumber(object):
def generate(self):
return random.randint(0,10)
# What you care about
class SecretGame(object):
def __init__(self, number_generator):
number = number_generator.generate()
print number
Ici, aucune des classes n'implémente une interface. Python ne s'en soucie pas, car la classe SecretGame tentera simplement d'appeler n'importe quel objet transmis. Si l'objet A une méthode generate (), tout va bien. Si ce n'est pas le cas: KAPUTT! Cette erreur ne sera pas constatée au moment de la compilation, mais au moment de l'exécution, donc éventuellement lorsque votre programme est déjà déployé et en cours d'exécution. C # vous en informerait bien avant que vous ne vous en approchiez.
La raison pour laquelle ce mécanisme est utilisé, a déclaré naïvement, parce que, dans OO, les fonctions fonctionnelles ne sont naturellement pas des citoyens de première classe. Comme vous pouvez le constater, KnownNumber et SecretNumber contiennent JUSTE les fonctions permettant de générer un nombre. On n'a pas vraiment besoin des cours. En Python, on peut donc simplement les jeter et choisir les fonctions par eux-mêmes:
# OO Approach
SecretGame(SecretNumber())
SecretGame(KnownNumber())
# Functional Approach
# Dependencies
class SecretGame(object):
def __init__(self, generate):
number = generate()
print number
SecretGame(lambda: random.randint(0,10))
SecretGame(lambda: 5)
Un lambda est simplement une fonction déclarée "en ligne, au fur et à mesure" . Un délégué est identique en C #:
class Game
{
public Game(Func<int> generate)
{
Console.WriteLine(generate())
}
}
new Game(() => 5);
new Game(() => new Random().Next(0, 10));
Les derniers exemples ne sont pas possibles comme cela en Java, car Java ne peut pas bouger avec des fonctions comme les deux autres (Python et C #) peuvent le faire. Là, les interfaces sont votre seul moyen de speficiying un comportement de cette façon dans av.
Techniquement, je décrirais une interface comme un ensemble de moyens (méthodes, propriétés, accesseurs ... le vocabulaire dépend du langage que vous utilisez) pour interagir avec un objet. Si un objet prend en charge/implémente une interface, vous pouvez utiliser toutes les méthodes spécifiées dans l'interface pour interagir avec cet objet.
Sémantiquement, une interface peut également contenir des conventions sur ce que vous pouvez ou ne pas faire (par exemple, l'ordre dans lequel vous pouvez appeler les méthodes) et sur ce que vous pouvez assumer en retour sur l'état de l'objet, compte tenu de votre interaction. loin.
interface est "quel travail" une méthode ne "comment" pas ... . C'est un contrat .. Comme dans la file d'attente prioritaire, vous savez quoi en faire, mais l'implémentation sous-jacente que vous ne connaissez pas. La classe s’engage à ne jamais modifier les "effets" des opérations existantes et le client s’engage à utiliser la classe Strictement sur la base de son interface et à ignorer les détails de la mise en oeuvre
Layman eg.:Pensez à disposer d’une télécommande universelle pouvant contrôler n’importe quel téléviseur... Qu’il s’agisse d’un ancien modèle à tube ou utilisant un LCD ou un écran plasma ..__ , puis 5, puis Entrée, et l’un des écrans affichera le canal 25, bien que le mécanisme utilisé pour ce faire diffère grandement selon la technologie sous-jacente.
Personnellement, je vois une interface comme un modèle. Si une interface contient la définition des méthodes foo () et bar (), toutes les classes qui utilisent cette interface ont les méthodes foo () et bar ().
Considérons un homme (utilisateur ou un objet) qui veut que du travail soit fait. Il contactera un intermédiaire (Interface) qui aura un contrat avec les entreprises (objets du monde réel créés à l'aide de classes implémentées). Peu de types de travaux seront définis par lui par les entreprises qui mettront en œuvre et lui donneront des résultats . Chaque entreprise mettra en œuvre les travaux à sa manière mais le résultat sera le même. Comme cet utilisateur, son travail sera effectué à l’aide d’une seule interface ..__Je pense qu’Interface agira comme une partie visible des systèmes avec peu de commandes qui seront définies en interne par les sous-systèmes internes d’application.
À mon avis, interface a une signification plus large que celle qui lui est couramment associée en Java. Je définirais "interface" comme un ensemble d'opérations disponibles avec certaines fonctionnalités communes, qui permettent de contrôler/surveiller un module.
Dans cette définition, j'essaie de couvrir à la fois les interfaces de programmation, où le client est un module et les interfaces humaines (interface graphique par exemple).
Comme d'autres l'ont déjà dit, une interface a toujours un contrat derrière elle, en termes d'entrées et de sorties. L'interface ne promet rien sur le "comment" des opérations; il ne garantit que certaines propriétés du résultat, compte tenu de l'état actuel, de l'opération sélectionnée et de ses paramètres.
Comme ci-dessus, les synonymes de "contrat" et "protocole" sont appropriés.
L'interface comprend les méthodes et les propriétés auxquelles vous pouvez vous attendre d'une classe.
Ainsi, si une classe Cheetos Bag implémente l'interface Chip Bag, vous devez vous attendre à ce que Cheetos Bag se comporte exactement comme tout autre Chip Bag. (C'est-à-dire exposer la méthode .attemptToOpenWithoutSpillingEverywhere(), etc.)
Une interface sépare les opérations sur une classe de l'implémentation à l'intérieur. Ainsi, certaines implémentations peuvent fournir de nombreuses interfaces.
Les gens le décrivent généralement comme un "contrat" pour ce qui doit être disponible dans les méthodes de la classe.
Ce n'est absolument pas un projet, car cela déterminerait également la mise en œuvre. Une définition de classe complète pourrait être considérée comme un modèle.
Une interface définit ce qu'une classe qui en hérite doit implémenter. De cette manière, plusieurs classes peuvent hériter d’une interface, et grâce à cet héritage, vous pouvez
- assurez-vous que tous les membres de l'interface sont implémentés dans la classe dérivée (même s'il ne s'agit que de lancer une exception)
- Abstrait la classe elle-même de l'appelant (lance une instance d'une classe sur l'interface et interagit avec elle sans avoir besoin de savoir ce qu'est la classe dérivée IS)
pour plus d'informations, consultez cette page http://msdn.Microsoft.com/en-us/library/ms173156.aspx
Définition conventionnelle - Une interface est un contrat qui spécifie les méthodes à implémenter par la classe qui l'implémente.
La définition de l'interface a évolué au fil du temps. Pensez-vous que l'interface n'a que des déclarations de méthodes? Qu'en est-il des variables finales statiques et des définitions par défaut après Java 5?.
Les interfaces ont été introduites en Java à cause du problème de Diamond avec l'héritage multiple et c'est ce qu'elles ont l'intention de faire.
Les interfaces sont les structures créées pour résoudre le problème de l'héritage multiple et peuvent avoir des méthodes abstraites, des définitions par défaut et des variables finales statiques.
Une limite à travers laquelle deux systèmes communiquent.
Les interfaces indiquent comment certains OO langages réalisent polymorphisme ad hoc . Le polymorphisme ad hoc est simplement constitué de fonctions portant les mêmes noms et opérant sur des types différents.
En bref, le problème fondamental qu'une interface tente de résoudre est de séparer la manière dont nous utilisons quelque chose de la manière dont elle est mise en œuvre. Mais vous devriez considérer l'interface n'est pas un contrat . Lire plus ici .