Quelle est la définition de «interface» dans la programmation orientée object

Ok, un de mes amis va et vient sur quelle “interface” signifie en 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 déroutants du développement.

C’est en fait un concept d’abstraction et d’encapsulation. Pour une “case” donnée, il déclare les “entrées” et les “sorties” de cette case. 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’il ne fait pas, c’est qu’il ne définit pas la sémantique de ces opérations, bien qu’il soit courant (et très 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: regardez votre téléviseur lorsqu’il est éteint. Son interface est constituée des boutons, des différentes fiches et de l’écran. Sa sémantique et son comportement consistent à prendre des entrées (par exemple, la programmation par câble) et à avoir des sorties (affichage à l’écran, son, etc.). Cependant, lorsque vous regardez un téléviseur non branché, vous projetez votre sémantique attendue dans une interface. Pour tout ce que vous savez, le téléviseur pourrait tout simplement exploser lorsque vous le twigz. Cependant, sur la base de son “interface”, vous pouvez supposer qu’il ne produira aucun café car il ne contient pas d’eau.

Dans la programmation orientée object, une interface définit généralement l’ensemble des méthodes (ou messages) auxquelles une instance d’une classe possédant cette interface peut répondre.

Ce qui ajoute à la confusion, c’est que dans certaines langues, comme Java, il existe une interface réelle avec sa sémantique spécifique au langage. En Java, par exemple, il s’agit d’un ensemble de déclarations de méthode, sans implémentation, mais une interface correspond également à un type et obéit à différentes règles de typage.

Dans d’autres langages, comme C ++, vous n’avez pas d’interfaces. Une classe elle-même définit des méthodes, mais vous pouvez considérer l’interface de la classe comme une déclaration des méthodes non privées. En raison de la manière dont C ++ comstack, vous obtenez des fichiers d’en-tête où vous pouvez 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 la confusion est que dans la plupart des langues, 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 une définition), l’interface ressemble à un squelette ou contour de la classe.

Considérons 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 “Jetez-moi quelque chose avec lequel je peux bash le zombie!”

Maintenant, considérez:
Vous n’avez pas spécifié (ni vous en souciez) exactement ce que votre ami choisira de lancer;
… Mais ça n’a pas d’importance, tant que:

  • C’est quelque chose qui peut être jeté (il ne peut pas vous lancer le canapé)

  • C’est quelque chose que vous pouvez saisir (espérons qu’il n’a pas jeté un shuriken)

  • C’est quelque chose que vous pouvez utiliser pour bash les cerveaux du zombie (qui exclut les oreillers et autres)

Peu importe si vous obtenez 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 que vous devez respecter ou auquel vous devez vous conformer, selon que vous êtes un exécutant 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 la manière dont vous pouvez interagir avec une classe, c’est-à-dire les méthodes qu’elle prend en charge.

Pour moi, une interface est un modèle de classe, est-ce la meilleure définition?

Un plan comprend généralement les composants 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 se compose des signatures des méthodes et des valeurs des constantes, ainsi que d’un “contrat comportemental” (généralement informel) entre les classes qui implémentent l’interface et d’autres qui l’utilisent.

Techniquement, je décrirais une interface comme un ensemble de méthodes (méthodes, propriétés, accesseurs … le vocabulaire dépend de la langue que vous utilisez) pour interagir avec un object. Si un object prend en charge / implémente une interface, vous pouvez utiliser toutes les méthodes spécifiées dans l’interface pour interagir avec cet object.

Sémantiquement, une interface peut également contenir des conventions sur ce que vous pouvez faire ou ne pas faire (par exemple, l’ordre dans lequel vous pouvez appeler les méthodes) et sur ce que vous pouvez en retour atsortingbuer à l’état de l’object. loin.

En programmation, une interface définit le comportement d’un object, 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 de jeu nécessite un numéro secret. Pour le tester, vous souhaitez injecter ce qui sera utilisé comme un numéro secret (ce principe s’appelle Inversion du contrôle).

La classe de jeu veut être “ouverte d’esprit” sur ce qui va réellement créer le nombre aléatoire, par conséquent, elle demandera à son constructeur “n’importe quoi, qui a une méthode Generate”.

Tout d’abord, l’interface spécifie les opérations qu’un object fournira. Il contient juste ce à quoi il ressemble, mais aucune implémentation réelle n’est donnée. Ceci est juste la signature de la méthode. Classiquement, dans C #, les interfaces sont préfixées par un I. Les classes implémentent maintenant l’interface IGenerate. Cela signifie que le compilateur s’assurera qu’ils ont tous deux une méthode qui renvoie un int et s’appelle Generate . Le jeu s’appelle maintenant deux objects différents, chacun mettant en œuvre l’interface correcte. D’autres classes produiraient une erreur lors de la construction du code.

Ici, j’ai remarqué l’analogie du plan directeur que vous avez utilisé:

Une classe est généralement considérée comme un modèle pour un object. Une interface spécifie quelque chose qu’une classe devra faire, on pourrait donc dire que ce n’est en fait qu’un modèle 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 briser. Pensez à une interface comme un contrat. La classe qui le “signe” sera légalement tenue (imposée par la police du compilateur) de se conformer aux termes et conditions du contrat. Cela signifie qu’il devra faire ce qui est spécifié dans l’interface.

Tout cela est dû à la nature statique de certains langages OO, comme c’est le cas avec Java ou C #. En Python par contre, 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 préoccupe pas, car la classe SecretGame essaiera d’appeler n’importe quel object transmis. Si l’object A une méthode generate (), tout va bien. Si ce n’est pas le cas: KAPUTT! Cette erreur ne sera pas visible à la compilation, mais à l’exécution, donc peut-être lorsque votre programme est déjà déployé et en cours d’exécution. C # vous avertirait bien avant votre arrivée.

La raison pour laquelle ce mécanisme est utilisé, naïvement déclaré, car dans les langues OO, les fonctions naturelles ne sont pas des citoyens de première classe. Comme vous pouvez le voir, KnownNumber et SecretNumber contiennent JUST les fonctions permettant de générer un nombre. On n’a pas vraiment besoin des cours. En Python, on pouvait donc simplement les jeter et choisir les fonctions par elles-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 juste une fonction, qui a été déclarée “en ligne, au fur et à mesure”. Un délégué est la même chose en C #:

 class Game { public Game(Func generate) { Console.WriteLine(generate()) } } new Game(() => 5); new Game(() => new Random().Next(0, 10)); 

Ces derniers exemples ne sont pas possibles comme cela en Java, car Java ne peut pas se déplacer avec des fonctions comme les deux autres (Python et C #). Là, les interfaces sont votre seul moyen de définir le comportement de cette manière dans av.

Personnellement, je vois une interface comme un modèle. Si une interface contient la définition des méthodes foo () et bar (), alors vous savez que chaque classe utilisant cette interface a les méthodes foo () et bar ().

Considérons un homme (utilisateur ou object) qui souhaite que des travaux soient effectués. Il contactera un intermédiaire (Interface) qui aura un contrat avec les entresockets (objects du monde réel créés à l’aide de classes implémentées). Il définira peu de types d’œuvres que les entresockets mettront en œuvre et lui donneront des résultats. Chaque entreprise mettra en œuvre le travail à sa manière, mais le résultat sera le même. Comme cet utilisateur va faire son travail en utilisant 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’implémentation.

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 modèle, 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 façon, plusieurs classes peuvent hériter d’une interface, et à cause de cet inheritance, vous pouvez

  • assurez-vous que tous les membres de l’interface sont implémentés dans la classe dérivée (même si c’est juste pour lancer une exception)
  • Abstrait de la classe elle-même à partir de l’appelant (transtyper une instance d’une classe vers l’interface et interagir avec elle sans avoir besoin de savoir ce qu’est la classe réelle dérivée)

pour plus d’informations, voir http://msdn.microsoft.com/en-us/library/ms173156.aspx

À mon avis, l’interface a un sens plus large que celui qui lui est généralement associé dans Java. Je définirais “interface” comme un ensemble d’opérations disponibles avec des fonctionnalités communes, permettant de contrôler / surveiller un module.

Dans cette définition, j’essaie de couvrir à la fois les interfaces programmatiques, 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, 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 parameters.

Comme ci-dessus, les synonymes de “contrat” ​​et “protocole” sont appropriés.

L’interface comprend les méthodes et les propriétés que vous pouvez vous attendre à voir exposées par une classe.

Donc, si un Cheetos Bag classe implémente l’interface Chip Bag , vous devez vous attendre à ce qu’un Cheetos Bag se comporte exactement comme n’importe quel autre Chip Bag . (C’est-à-dire, exposez la méthode .attemptToOpenWithoutSpillingEverywhere() , etc.)

l’interface est “quel travail” une méthode ne “comment” pas. C’est un contrat. Comme dans la queue prioritaire, vous savez quoi en faire, mais l’implémentation sous-jacente que vous ne connaissez pas. La classe accepte de ne jamais modifier les “effets” des opérations existantes, et le client accepte d’utiliser la classe ssortingctement sur la base de son interface et d’ignorer tous les détails d’implémentation.

Layman par exemple: Pensez à une télécommande universelle capable de contrôler n’importe quel téléviseur, qu’il s’agisse d’un ancien modèle de tube ou d’un modèle utilisant un écran LCD ou plasma. Vous appuyez sur 2, puis sur 5, puis sur Entrée, et l’un des écrans affichera le canal 25, même si le mécanisme pour y arriver est très différent selon la technologie sous-jacente.

Une frontière à travers laquelle deux systèmes communiquent.

Les interfaces sont la manière dont certains langages OO réalisent un polymorphism ad hoc . Le polymorphism ad hoc est simplement une fonction avec les mêmes noms fonctionnant sur différents types.

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 changé avec le temps. Pensez-vous que l’interface ne contient que des déclarations de méthodes? Qu’en est-il des variables statiques et des définitions par défaut après Java 5?

Les interfaces ont été introduites dans Java à cause du problème Diamond avec l’inheritance multiple et c’est ce qu’elles ont réellement l’intention de faire.

Les interfaces sont les constructions créées pour résoudre le problème de l’inheritance multiple et peuvent avoir des méthodes abstraites, des définitions par défaut et des variables finales statiques.

http://www.quora.com/Why-does-Java-allow-static-final-variables-in-interfaces-when-they-are-only-intended-to-be-contracts