Je comprends les principes du codage vers les interfaces - pour dissocier l'implémentation de l'interface et permettre aux implémentations de l'interface d'être permutées dans et hors.
Dois-je coder des interfaces pour chaque classe que j'écris ou est-ce exagéré ? Je ne veux pas doubler le nombre de fichiers source dans un projet, sauf si cela en vaut vraiment la peine.
Quels facteurs puis-je utiliser pour décider de coder par interface ou non?
En général je suis d'accord avec les autres réponses: utilisation de l'interface lorsque vous savez ou anticiper le changement et/ou de mise en œuvre différente, ou aller pour la testabilité.
Mais il n'est pas toujours facile de savoir à l'avance ce qui peut changer dans le futur, surtout si vous n'êtes pas tellement d'expérience. Je pense que la solution à ce problème est de refactoring: keep it simple (= pas d'interface), tant qu'il n'est pas nécessaire. Lorsque le besoin s'en fait sentir tout simplement faire un "Introduire ou Extraire de l'interface" refactoring (pris en charge par presque tous les honnêtes IDEs).
Lorsque vous le faites extraire uniquement les méthodes qui sont nécessaires par les appelants. N'hésitez pas à extraire plus d'un de séparer les interfaces (si pas tous les extraits méthodes sont vraiment cohérent).
Un pilote du refactoring peut-être le test: si vous ne pouvez pas facilement tester quelque chose avec les classes de seulement envisager l'introduction d'une ou plusieurs interface(s). Cela vous permettra également d'utiliser les moqueries qui peut grandement simplifier les tests dans de nombreux cas.
Edit: basé sur Tarski le commentaire que j'ai réalisé l'un de plus importants du scénario et/ou le réglage de l'précédentes déclarations:
Si vous fournir une API externe (pour les autres [sub], les projets ou vraiment libérer "à la sauvage"), puis en utilisant les interfaces de l'API (à l'exception de simples classes de valeur) est presque toujours une bonne idée.
Il vous permettra de changer l'impl si vous le souhaitez, sans déranger le code du client. Vous avez un problème uniquement si vous avez également à la modification de l'interface. Ne pas casser la compatibilité sera très difficile (sinon impossible).
Je l'utilise quand au moins une des conditions suivantes est remplie:
1) je veux dissocier sans rapport avec les modules/classes les unes des autres, et je veux qu'il soit réfléchie par le package java dépendances.
2) Lorsque le découplage est important en termes de dépendances de construction
3) Lors de la mise en œuvre peut changer grâce à la configuration ou dynamiquement à l'exécution (généralement en raison de certains modèle de conception)
4) Quand je veux une classe pour être testable, je fais du son "lien" vers des ressources externes interfaces, afin que je puisse utiliser maquette implémentations.
5) Moins commun: Quand je veux avoir une option pour limiter l'accès à certaines classe. Dans ce cas ma méthode retourne une interface à la place de la classe, de sorte que l'appelant sait que je ne comptez pas sur lui pour faire d'autres opérations sur la valeur de retour.
Non, chaque classe devrait pas avoir une interface. C'est trop carré.
Vous utilisez une interface lorsque vous avez besoin d'abstraire ce qui est fait de la façon dont c'est fait, et vous êtes certain que la mise en œuvre peut changer.
Jetez un oeil à la java.util Collections de l'API pour un bon exemple. La Liste de l'interface est une belle abstraction de l'idée générale d'une Liste, mais vous pouvez voir qu'il y a de nombreuses façons de la mettre en œuvre: ArrayList, LinkedList, etc.
Mise à JOUR: Alors que dire de cas où la conception d'un béton de classe, décide, après vous avez des clients qui une interface est nécessaire, et puis vous cassez vos clients par l'ajout d'une interface? Ouais, c'est ce qui se passe. Comment pouvez-vous savoir ce que vous ne savez pas? Aucun logiciel ou une méthode peut résoudre ce problème.
La bonne nouvelle pour vous est que l'extraction d'une interface à partir d'un béton de classe est un simple remaniement à faire pour vous et vos clients. IDEs gérer ce genre de chose régulièrement. Vous et vos clients faut en profiter.
Je dirais que les couches, comme les services et la persistance, il faut toujours avoir des interfaces. Tout ce qui peut être mandaté doit avoir une interface. Si vous êtes en train de faire Spring AOP, tout ce que vous voulez décorer avec un aspect devrait avoir une interface.
Modèle ou des objets de valeur, comme Personne, d'Adresse ou de Téléphone, ne doit pas avoir une interface. Une valeur immuable de l'objet ne doit pas avoir une interface.
Le reste de l'automne dans les zones d'ombre. Utilisez votre meilleur jugement.
Longue histoire courte, pas de. Vous êtes le créateur de l'application, de sorte que vous avez une bonne idée de ce qui pourrait changer. Certains de la conception des livres d'échantillons aller un peu fou sur elle, à mon avis, car ils semblent toujours pousser la conception des interfaces et non de la mise en œuvre n'importe quoi. Parfois, il est juste surpuissant. Pour ma dernière application (de petite taille), j'ai une interface de base de données parce que je pense qu'il y a une chance que je peut plus tard port sur le web et de passer à MySQL. Évidemment, dans la réalité, il serait facile de créer une base de données de l'interface en bas de la route de ma classe existante et ajoutez simplement "met en œuvre myDbInterface" plus tard, avec quelques petits changements. Cela fonctionne parce que je suis le seul développeur bien. Sur une grande équipe, ou autre type de produit, il peut être une réponse différente. Il suffit d'utiliser votre meilleur jugement (après la lecture de tous les bons de SORTE réponses, bien sûr).
J'aime à penser que l'on utilise des interfaces lors de la pluggability et le potentiel de différentes comportement est important. Les Services sont un ajustement parfait. On peut vouloir une implémentation par défaut, mais semblant(moqueur), etc en est une autre. De toute évidence, cela signifie qu'il devrait être un intf comme il y aura toujours au moins 2 formes.
Types de valeur d'autre part devrait être final classes. Ils ne doivent jamais être prolongée. Types de valeur comprennent quelque chose comme de la Banlieue, type mime. Si il y a des variations de ces utiliser la composition. Comme un objectif, j'ai essayer de mettre peu de comportement si l'un de mes types de valeur. La validation du type simple qu'il l'enveloppe etc est probablement la plus complexe chose qu'elle fait. Par exemple, Une classe de Couleur qui prend r/g/b doit s'assurer que chaque composant est comprise entre 0 et 255 et c'est tout.
Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.
