L'Interface Java Directives d'Utilisation — Sont des getters et setters dans une interface mauvais?
Ce que les gens pensent de la meilleure des lignes directrices à utiliser dans une interface? Ce qui devrait et ne devrait pas aller dans une interface?
J'ai entendu des gens dire que, en règle générale, une interface doit se contenter de définir le comportement et non l'état. Est-ce à dire qu'une interface ne doivent pas contenir de getters et setters?
Mon avis: Peut-être pas le cas pour les setters, mais parfois, je pense que les méthodes de lecture sont valables pour être placé dans une interface. Il s'agit simplement de faire respecter la mise en œuvre des classes pour mettre en œuvre les getters et donc à indiquer que les clients sont en mesure d'appeler ces méthodes pour vérifier quelque chose, par exemple.
Vous devez vous connecter pour publier un commentaire.
Je pense qu'il y a deux types d'interfaces déclarées en général:
CalculationService
. Je ne pense pas que les méthodesgetX
devrait être dans ce genre d'interface, et certainement passetX
. Ils ont tout à fait clair que la mise en œuvre de détails, ce qui n'est pas le rôle de ce type d'interface.Remarque: les collections de classes probablement dans le type n ° 2
Je ne vois pas pourquoi une interface ne peut pas définir des accesseurs et mutateurs. Par exemple,
List.size()
est effectivement un getter. L'interface doit définir le comportement plutôt que la mise en œuvre bien qu'il ne peut pas dire comment vous allez poignée l'état, mais elle peut exiger que vous pouvez l'obtenir et de le définir.Collection interfaces sont tout au sujet de l'état, par exemple - mais différentes collections peut stocker que de l'état de manières radicalement différentes.
EDIT: Les commentaires suggèrent que les getters et les setters impliquent un simple champ est utilisé pour la sauvegarde de stockage. - Je avec véhémence en désaccord avec cette interprétation. À mon avis il y a une indication que c'est "raisonnablement bon marché" pour obtenir/définir la valeur, mais pas qu'il est enregistré comme un champ avec une implémentation triviale.
EDIT: Comme indiqué dans les commentaires, c'est explicite dans la JavaBeans spécification la section 7.1:
Si la supposée implication ont été vrai, nous pourrions tout aussi bien exposer les propriétés des champs directement. Heureusement que cette implication n'est pas tenir: les accesseurs et mutateurs sont parfaitement en droit de calculer des choses.
Prenons l'exemple d'un composant avec
Croyez-vous, il y a une implication qu'il y a trois variables? Ne serait-il pas raisonnable d'avoir:
Ou (de préférence de l'OMI):
Ici, soit la propriété de la taille ou de la hauteur/largeur de propriétés à des fins de commodité seulement - mais je ne vois pas cela qui rend invalide en quelque sorte.
getX
etsetX
implique quex
est une propriété d'un objet que l'objet a une variablex
qui est accessible par le biais de ces méthodes.setX
etgetX
qui sont pas le simple accès à une variable sous-jacente de jouer avec le feu parce que la plupart des gens (à mon humble avis) supposons qu'ils sont.setX
méthodes où il n'y a pas de telle propriétéx
que je pense que la plupart des gens vont faire cette hypothèse, même si c'est une défaillance de l'un.setX
méthode pour être soutenu par une propriétéIl n'y a rien de mauvais en soi getters/setters. Cependant:
Ce sont toutes les lignes directrices, note.
Je ne pense pas qu'un haricot, une interface sur le dessus de cela, en général. Un javabean est une interface dans le sens plus général. Une Interface spécifie le contrat externe de quelque chose de plus complexe. Un javabean externe du contrat et de sa représentation interne sont identiques.
Je ne dis pas que vous ne devriez pas avoir des getters dans une interface, cependant. Il est parfaitement logique d'avoir un ReadableDataThingie interface est implémentée par DataThingieBean.
Pour commencer, au moins avec Java et à l'exclusion Exception des déclarations, vous ne pouvez pas définir le comportement complet sans état. En Java, les interfaces ne définit pas le comportement. Ils ne peuvent pas. Ce qu'ils définissent sont des types; les promesses de la mise en œuvre d'un ensemble de fonctionnalité des signatures peut-être avec quelques post-conditions wrt exceptions. Mais c'est tout. Comportement et de l'état sont définies par les classes qui implémentent ces interfaces.
Deuxièmement, si les getters et les setters sont définies dans une interface, ils n'ont pas vraiment définir le comportement complet (autres que l'on est pour la lecture et un pour écrire wrt un bien.) Vous pouvez avoir un comportement complexe derrière les setters et getters, mais ils ne peuvent être mis en œuvre dans les classes réelles. Il n'y a rien dans le langage Java qui peut nous permettre de définir librement le comportement dans les interfaces sauf pour la plus restrictive des cas.
Avec cela en considération, il n'y a rien de mal - syntaxiquement et sémantiquement - avec les setters et getters dans les interfaces.
Si votre demande est bien modélisé et le problème exige que vous disposez d'une interface définissant les setters et getters, pourquoi pas. Par exemple, jetez un oeil à la ServletResponse interface.
Maintenant, si nous regardons les getters et les setters du point de vue de la mise en œuvre de classes compatible avec les JavaBeans specs, alors vous n'avez pas besoin de définir des interfaces pour eux.
Mais si vous avez des choses qui nécessitent des setters et getters, comme un bean, et qui est également nécessaire pour être branché à la compilation de type (pas au moment de l'exécution comme un bean), et pour laquelle de multiples implémentations peuvent exister, alors oui, ce serait un appel à une interface qui définit les accesseurs et mutateurs.
Espère que cela aide.
Cette touche à l'ensemble des Accesseurs/Mutateurs sont mauvais sujet qui est abordé plusieurs fois sur ce site et ailleurs.
J'ai tendance à favoriser ne pas avoir des accesseurs dans l'interface, mais pour ajouter des collaborateurs à l'aide des arguments du constructeur pour la mise en œuvre.
Le fait que la mise en œuvre directe de quelque chose comme un getter ne devrait pas l'empêcher d'être dans une interface si elle doit l'être.
Pour en savoir plus: Pratique de Conception d'API Confessions d'un Framework Java Architecte (Jaroslav Tulach, 2008, Apress).
J'ai utilisé ce genre d'interfaces, par exemple, nous avions des cours avec des champs beginDate, endDate. Ces champs ont été dans de nombreuses classes et j'ai eu un cas d'utilisation, j'ai besoin d'obtenir ces dates pour les différents objets, donc j'ai extrait de l'interface et était très heureux 🙂
Fondamentalement, si la réponse à "j'ai besoin de connaître la valeur de [nom de l'etat, de la propriété, whateverThignAMaGit] afin de travailler avec une instance de celui-ci?" ... alors oui les accesseurs appartiennent dans l'interface.
Liste.size() de Jean-dessus est un exemple parfait d'un getter qui doit être défini dans une interface
Getters sont utilisés pour interroger l'état d'un objet - qui vous pouvez vraiment éviter lors de la conception de votre interface. Lire http://www.pragprog.com/articles/tell-dont-ask