J'écris un ensemble de classes de test junit en Java. Il existe plusieurs constantes, par exemple des chaînes dont j'aurai besoin dans différentes classes de test. Je pense à une interface qui les définit et chaque classe de test l'implémenterait.
Les avantages que je vois sont les suivants:
- accès facile aux constantes:
MY_CONSTANT
au lieu deThatClass.MY_CONSTANT
- chaque constante définie une seule fois
Cette approche est-elle plutôt une bonne ou une mauvaise pratique? J'ai l'impression d'abuser un peu du concept d'interfaces.
Vous pouvez répondre de manière générale aux interfaces / constantes, mais également aux tests unitaires s’il ya quelque chose de spécial.
Réponses:
Joshua Bloch déconseille cela dans son livre Effective Java :
Vous pouvez obtenir le même effet avec une classe normale qui définit les constantes, puis utiliser
import static com.example.Constants.*;
la source
Dans notre cas, nous procédons ainsi car les valeurs des constantes représentent un contrat pour les états finaux qu'une implémentation de service doit fournir. La mise de ces constantes dans l'interface spécifie les états finaux dans le contrat, et si une implémentation de l'interface ne les utilisait pas, elle ne ferait pas son travail.
Certaines constantes sont des détails d'implémentation. PARFOIS, ils ne le sont pas. Comme d'habitude, un ingénieur doit utiliser son cerveau pour décider quoi faire, et ne pas s'appuyer sur un modèle ou une pratique générale.
la source
Je ne pense pas que ce soit une bonne chose d'avoir des interfaces uniquement pour les constantes.
Mais si une interface qui définit le comportement (les méthodes implémentant des classes doivent l'implémenter), a des constantes, c'est bon. Si "des détails du développeur sont divulgués " dans l'API, c'est que c'est comme ça que ça devrait être. De plus, ils impliquent que l'implémenteur implémente les méthodes foo et bar.
Prenons par exemple l'interface java.awt.Transparency. Il a des constantes OPAQUE, BITMASK et TRANSLUCENT, mais aussi une méthode getTransparency ().
Si le concepteur y met ces constantes, il pense qu'il serait assez stable pour faire partie de l'interface, à l'instar de getTransparency ().
la source
Pensez que c'est un point de vue surtout populaire dans les endroits où la conception par contrat prévaut.
Les interfaces sont des contrats. Le fait de placer des constantes dans des interfaces signifie que chaque classe qui respecte le contrat accepte la valeur / le concept identifié par la constante.
la source
"at most expose their names"
sans exposer les valeurs?Une entreprise où je travaillais à fait une utilisation intensive des produits importés d'interface 1 constantes. Je ne ressens aucun mal.
La question que vous devriez vous poser est la suivante: quelle est l’importance de l’espacement des noms pour vous? Dans le cas des constantes, c'est vraiment tout ce qu'une classe agit comme. Si vous avez des milliers de constantes, vous ne voudrez peut-être pas que toutes ces constantes soient toujours disponibles.
La bonne chose à propos des interfaces est que cela vous donne l’avantage de travailler dans un sens ou dans l’autre - introduisez tous les espaces de noms dont vous avez besoin, ou aucun d’entre eux (et accédez-y explicitement avec
MyInterface.CONSTANT
). À peu près la même chose queimport static MyInterface.*
, mais un peu plus évident.1: Si vous n'êtes pas familier avec Java, je ne parle pas du
import
mot clé, je veux simplement dire introduit viaimplements MyConstantsInterface
la source
Je viens d'un milieu principalement influencé par la «méthode Ada» et la «méthode .Net». Je dirais non, qu'il n'est probablement pas préférable de déclarer des constantes dans des interfaces. Ce n'est techniquement pas permis en c #.
La raison pour laquelle je dis non, c'est qu'une interface est une forme de contrat qui définit un comportement, et non un état ou une structure. Une constante implique une sorte d'état (primitif) ou un aspect d'état (composite ou agrégé).
Je peux comprendre l'envie de mettre les valeurs par défaut et les valeurs prédéfinies à la disposition de tous ceux qui implémentent l'interface, mais peut-être que l'état par défaut serait mieux décrit dans un objet ou un modèle abstrait ou valeur, où les valeurs par défaut auraient au moins un contexte minimal.
Pour un guide plus technique: download.oracle.com/javase/1.5.0/docs/guide/language/static-import.html
la source
So when should you use static import? Very sparingly! Only use it when you'd otherwise be tempted to declare local copies of constants, or to abuse inheritance (the Constant Interface Antipattern). In other words, use it when you require frequent access to static members from one or two classes. If you overuse the static import feature, it can make your program unreadable and unmaintainable, polluting its namespace with all the static members you import.
Référence de Oracle DocsNon, ce n'est pas une mauvaise pratique générale.
Le fait est que les constantes, comme tout autre artefact, doivent être introduites selon les règles de visibilité minimale et de niveau d'abstraction approprié.
Utiliser la syntaxe uniquement parce que vous le pouvez est le vrai problème.
la source