OK, donc je rassemble que les interfaces sont un moyen d'appliquer qu'un objet implémente une certaine quantité de fonctionnalités, sans avoir à utiliser l'héritage. Genre de comme un contrat. Et je semi-voir le point d'eux.
Mais si tout ce que vous avez dans l'interface est: p> et il n'a aucune implémentation en tant que telle, alors que celui qui utilise votre interface. doit l'écrire à partir de zéro, chaque fois. p> Si vous créez un certain nombre de classes, toutes les caractéristiques et la mise en œuvre ne sont que légèrement différentes, cela va être beaucoup de travail acharné. P> Toute aide pour que ma tête est appréciée, c'est apprécié parce que je sais que c'est vraiment important. p> p>
13 Réponses :
Préférez la composition sur l'héritage. de cette façon, vous pouvez mettre en œuvre (dire) manger () Dans une classe qui est incorporée à tous vos animaux en tant que membre de données. Écrivez-la une fois, réutilisez-le, mais d'une manière qui ne lie pas une sorte de fonctionnalité explicitement à une autre. P>
Si vous aviez deux (ou dix) façons de manger différentes, vous pouvez les échanger au besoin. P>
Bien que la composition semble le meilleur moyen d'éviter la duplication de code dans ce cas particulier, cette réponse a tendance à penser que les interfaces sont inutiles dans Java. N'oubliez pas qu'il existe également un autre principe de conception disant «programme d'interfaces, non de classes concrètes». Ainsi, les interfaces en Java sont définitivement quelque chose à comprendre et à utiliser presque partout.
Bon point. Je viens de modifier pour ajouter le bit "Swing Out", que je pense peut y remédier. Merci.
Droite, vous devez la mettre en œuvre jamais temps, mais vous pouvez la mettre en œuvre différemment à chaque fois et que toute classe qui appelle cela n'a pas besoin de s'inquiéter de la manière dont elle est mise en œuvre. p>
Par exemple, si vous avez un objet de zoo avec une bande d'animaux (nouveau tigre (), lion (), ours ()) alors votre zoo peut faire pour chaque animal A dans une collection A.eat () et elle marchera. Le zoo ne se soucie pas qu'il existe trois types d'animaux différents qui mangent de manière totalement différente. P>
Vous êtes confondre des interfaces et des héritions. Ce sont des concepts différents et peuvent se compléter l'un à l'autre. Si toutes les méthodes de consommation ne sont que légèrement différentes, vous pouvez créer une classe de base qui contiendra le code commun et sera invoquée à partir des sous-classes via des méthodes de remplacement qui ajoutent les différentes parties. La classe de base peut toujours mettre en œuvre l'interface. J'espère que c'est clair. P>
et il n'a pas de mise en œuvre en tant que tel Ensuite, quiconque utilise votre interface a l'écrire à partir de gratter. Tout le temps. P>
Chaque implémentation de l'interface peut être différente. Le point est que vous pouvez utiliser l'interface sans connaître la mise en œuvre. Considérer exemple: p>
xxx pré> Votre application peut utiliser
iLogger code> interface pour les erreurs de journalisation / informations de débogage, etc. Mais peu importe la mise en œuvre de l'enregistreur - Il peut êtrefichiersystemlogger code> ouDatabasElogger code> ou toute autre implémentation. Vous pourrez donc substituer des implémentations à tout moment sans changer tous les endroits dans le code où la journalisation a été mentionnée. P> blockQquote>
Si vous créez un certain nombre de classes, toutes les caractéristiques et la mise en œuvre ne sont que légèrement différentes, cela va être beaucoup de travail acharné. P>
Dans ce cas, vous êtes facilement autorisé à créer une autre couche dans votre hiérarchie de classes qui implémentent
animal code> mais est une classe ancêtre pour tous les animaux qui mangent d'une manière ou d'une autre, par exemple p> < Pré> xxx pré>et vous êtes autorisé à remplacer
manger code> à l'aide desuper.eat () code> et changeant uniquement la partie légère .. p>Vous devez regarder la réutilisation et l'encapsulation de Code impatient des composants en même temps .. Ensuite, si votre interface ne caractérise vraiment pas la classe elle-même, mais juste un composant de celui-ci, vous pouvez passer par la composition comme suggérée par Carl Manaster. p> blockquote>
Vous devez penser à une interface comme une déclaration de comportement faisant autorité em>, qui n'a rien à voir avec les problèmes de mise en œuvre en premier lieu. P>
Si vous souhaitez éviter la duplication de code, vous utilisez une classe de base abstraite en combinaison avec l'interface. Vous pouvez ensuite implémenter toutes les choses qui pourraient être répétées dans toutes les classes d'implémentation d'interface sinon. P>
hth.
Thomas P>
Vous y réfléchissez en arrière. Au lieu de penser à la mise en œuvre d'abord, vous pensez d'abord du comportement (comme décrit par la signature de la méthode). Ensuite, vous mettez en œuvre le comportement selon que nécessaire dans les classes de base donnant un système beaucoup plus flexible et extensible. Vous avez rejeté «la conception par contrat» assez rapidement, mais c'est une stratégie de conception clé et la base des services Web, SOA, etc. P>
Utiliser des interfaces est davantage de donner au code consommateur un moyen de savoir ce que vous attendez de celui-ci, plutôt que de vous préoccuper des détails du code consommateur. P>
Par exemple, l'une des façons que nous utilisons des interfaces a beaucoup dans notre couche de couche d'entreprise / d'accès aux données. P>
Parce que notre ensemble de couche d'entreprise (BL) communiquera directement avec l'ensemble de couche d'accès aux données (DAL), le DAL ne peut pas communiquer directement avec le BL. Que se passe-t-il si le dal veut utiliser des objets plutôt que des champs individuels? Vous devriez définir vos propres objets DAL et les hydrater avec l'entrée que vous venez de recevoir. Fondamentalement, beaucoup plus de travail, plus de ressources consommées et de multiples objets qui représentent les mêmes données qui créent un cauchemar de maintenance. P>
Mais, si vous définissez des interfaces dans le DAL, vous pouvez dire aux consommateurs du DAL ce qu'il attend. Ensuite, vous pouvez implémenter ces interfaces dans le BL et passer des instances des interfaces au lieu des objets BL. P>
Les interfaces sont toutes sur la résiliation des détails de la mise en œuvre où ils ne sont pas absolument nécessaires. P>
[modifier] Si vous avez beaucoup d'objets qui font des choses similaires, une combinaison d'une interface et d'une classe de base avec des méthodes d'alternance / virtuelles peut être plus utile qu'une interface. P>
Les interfaces sont le seul moyen de créer plusieurs héritages dans Java. P>
Dites que vous créez une classe Mais maintenant, disons que vous avez un Notez également qu'un animal code>. Et tous les animaux, y compris les humains qui prolongent. Et chacun de ces animaux hérite des méthodes courantes comme manger, respirer, etc. p>
mathproblem code> classe.
Et vous voulez avoir certaines classes qui peuvent résoudre ce problème en faisant passer le problème à un résoudre (problème MathProblem) code> méthode.
Et vous savez qu'un humain code>, mais aussi un ordinateur code> pourrait résoudre le problème de mathématique. Donc, ils doivent tous les deux être capables de résoudre ce problème. Vous pourriez être en mesure d'obtenir l'ordinateur pour étendre une classe mathsolver code> qui a la méthode, mais l'homme étend déjà l'animal et ne peut rien étendre d'autre chose. Donc, une meilleure façon consiste à faire une interface MathSolver et à avoir à la fois humain code>, ordinateur code> et toutes les autres classes qui doivent résoudre des problèmes de mise en œuvre. P>
humain code> et un ordinateur code> pourrait résoudre les problèmes de manière complètement différente, puisque leurs objets si différents. C'est ce que les interfaces sont les meilleures pour. Définir certaines capacités qui coupent de multiples hiérarchies d'héritage et peuvent avoir des implémentations très différentes, mais peuvent tous être transmis à une méthode qui accepte l'un d'entre eux. Pensez à la interface code> comparable; Ce n'est pas quelque chose qu'une certaine classe d'objets a, toutes sortes de choses peuvent être comparées et généralement de différentes manières. Mais vous pouvez toujours appeler trier sur une liste code> de d'objets comparables code> car vous savez qu'ils ont une certaine commande, si elles sont numéros code>, animaux code>, ordinateurs code> ou autre chose (tant qu'ils implémentent comparable code> et définir leur commande). P>
+1 - Je pense qu'il est important d'ajouter qu'il existe deux objectifs d'héritage: (1) Autoriser les objets de classe héritée à utiliser à la place d'objets de classe de base, et (2) permettre des objets de classe héréditaires à utiliser la base de la base. -Les comportements de classes. Les interfaces ne font rien d'utile vers le deuxième but, mais sont très utiles pour la première fois.
Ce n'est pas vraiment une réponse tant comme un exemple que je trouve utile lorsque je pense aux interfaces, mais réfléchissez à l'interface L'utilisateur peut implémenter cela, mais elle veut. Si une personne comparable implémente comparable collections.sort () code> qui nécessitent que les éléments à trier doivent être comparables (comment une comparaison pourrait-elle être faite? ) p> p>
et vieux fil, je sais. Mais je viens de lire "les interfaces sont le seul moyen de créer plusieurs héritages dans Java". C'est très faux, car la délégation (ou le «compositon» en tant que Carl a dit) est le seul moyen d'obtenir de multiples héritages (rappelez-vous: «La délégation est une héritage», bien, presque). P>
Vous n'avez besoin que d'interfaces pour dire au développeur "Hey, n'oubliez pas de déléguer ceci ou cette classe"! Les interfaces ne sont nécessaires que pour rappeler une délégation correcte (ou en général: la mise en œuvre), mais elles ne peuvent pas hériter de code. Avec plusieurs interfaces d'héritage ne serait pas nécessaire du tout. P>
En réalité, vous n'avez pas vraiment besoin d'interfaces pour créer un programme de travail, ils sont simplement des aides sans fonction ou code fonctionnel. BTW Thomas était très juste avec les classes abstraites, elles sont beaucoup plus importantes que les interfaces, car c'est là que vous pouvez obtenir du code réutilisable de. P>
Normalement, lorsque j'écris une application Java, je ne crée que des interfaces à la fin, en tant qu'employeur pour les futurs programmeurs. Ou je ne crée aucune interface du tout; d p>
Les interfaces ne sont pas des aides. Ce ne sont pas des contrats de rappeler aux développeurs de mettre en œuvre des méthodes. Les interfaces doivent être codées, de sorte que vous puissiez découpler des implémentations spécifiques des endroits où la fonctionnalité est souhaitée.
Une raison majeure est que vous pouvez créer un objet à l'aide d'une référence d'interface, similaire à une méthode abstraite. Lorsque vous faites cela, chaque objet qui implémente l'interface peut y être attribué. Par exemple, si le chien et la voiture implémentent lavable, vous pouvez faire: P>
washable wd = nouveau chien (); p>
wc lavable = nouvelle voiture (); p>
si lavable a la méthode abstraite publique WASH (), vous pouvez le faire: p>
wd.wash (); p>
wc.wash (); p>
et leurs méthodes respectives seront appelées. Cela signifie également que vous pouvez accepter une interface en tant que paramètre pour une méthode, ce qui signifie que vous n'avez pas à ajouter du code inutile pour traiter chaque classe qui implémente une certaine interface. p>
voir ici pour une explication plus détaillée: http://www.artima.com/ Objetandjava / Webuscript / polymorphishisminterfaces1.html P>
Belle explication
Utilisation d'une interface Java Nous pouvons obtenir une généralisation à travers la sous-classe. La généralisation signifie ici des sous-classes ayant le même comportement mis en œuvre d'une manière différente. P>
Interface permet de définir la normalisation de toutes les sous-classes qui l'applique. Il spécifie "ce que" les sous-classes doivent avoir mais n'applique pas comment cela devrait avoir. P>
Body d'interface fournit 100% d'abstraction, de sorte que la sous-classe ne manquait aucune mise en œuvre de la méthode abstraite. Ce n'est pas possible si nous utilisons des classes abstraites. P>
de couplage (couplage lâche) fort> p>
Tout en développant une application, le code qui interagit avec les utilisateurs finaux peut être couplé de manière lâche au code exécuté sur le serveur [B l C] à l'aide d'interfaces. P>
héritage multiple fort> p>
Utilisation d'interfaces Nous pouvons obtenir un MI qui n'est pas possible en utilisant des classes. p>
Désolé pour mon terrible 'typos' Carl vient de cliquer sur le bouton sans vraiment le lire à fond. Beaucoup dans mon esprit il semble. Des trucs riches en grinçons lorsque vous regardez les erreurs.
Stackoverflow.com/a/24436493/1286942