É uma prática ruim ter uma interface para definir constantes?

Estou escrevendo um conjunto de classes de teste junit em Java. Existem várias constantes, por exemplo, strings que eu precisarei em diferentes classes de teste. Estou pensando em uma interface que os define e toda classe de teste o implementaria.

Os benefícios que vejo são:

• acesso fácil a constantes: em MY_CONSTANTvez deThatClass.MY_CONSTANT
• cada constante definida apenas uma vez

Essa abordagem é uma boa ou má prática? Sinto vontade de abusar um pouco do conceito de interfaces.

Você pode responder geralmente sobre interfaces / constantes, mas também sobre testes de unidade, se houver algo de especial nisso.

Joshua Bloch desaconselha isso em seu livro Effective Java :

O fato de uma classe usar algumas constantes internamente é um detalhe de implementação. A implementação de uma interface constante faz com que esse detalhe da implementação vaze para a API exportada das classes. Não tem importância para os usuários de uma classe que a classe implemente uma interface constante. De fato, pode até confundi-los. Pior, representa um comprometimento: se em uma versão futura a classe for modificada para não precisar mais usar as constantes, ainda deverá implementar a interface para garantir a compatibilidade binária.

Você pode obter o mesmo efeito com uma classe normal que define as constantes e, em seguida, use import static com.example.Constants.*;

No nosso caso, estamos fazendo isso porque os valores das constantes representam um contrato para os estados finais que uma implementação de serviço é necessária para fornecer. A inserção dessas constantes na interface especifica os estados finais como parte do contrato e, se alguma implementação da interface não as utilizasse, ela não faria seu trabalho.

Às vezes, constantes são detalhes de implementação. Às vezes eles não são. Como sempre, um engenheiro precisa usar seu cérebro para decidir o que fazer e não confiar em um padrão ou prática abrangente.

Não acho bom ter interfaces apenas para constantes.

Mas se uma interface que define comportamento (métodos que implementam classes devem implementar), tem constantes, tudo bem. Se "vazar os detalhes de algum implementador" na API, é porque é assim que deve ser. Também estão vazando que o implementador implementa métodos foo e bar.

Tomemos, por exemplo, a interface java.awt.Transparency. Possui constantes OPAQUE, BITMASK e TRANSLUCENT, mas também possui o método getTransparency ().

Se o designer colocar essas constantes lá, é porque ele pensou que seria estável o suficiente para fazer parte da interface, como getTransparency ().

Pense que é um ponto de vista mais popular em lugares onde o design por contrato é predominante.
Interfaces são contratos. Colocar constantes nas interfaces significa que toda classe que cumpre o contrato concorda com o valor / conceito identificado pela constante.

Uma empresa em que trabalhei fez uso pesado de ¹ constantes importadas pela interface . Não sinto nenhum mal disso.

A pergunta que você deve se perguntar é: qual a importância do namespace para você? No caso de constantes, é realmente tudo o que uma classe age. Se você possui milhares de constantes, talvez não queira que todas estejam sempre disponíveis.

O bacana das interfaces é que ela oferece o benefício de trabalhar de qualquer maneira - traga todos os namespaces necessários ou nenhum deles (e acesse-os explicitamente com MyInterface.CONSTANT). Praticamente a mesma coisa que import static MyInterface.*, mas um pouco mais óbvio.

^{1: Se você não conhece o Java, não estou falando da importpalavra - chave, mas sim trazida porimplements MyConstantsInterface}

Eu venho de um contexto que é principalmente influenciado principalmente pelo 'caminho Ada' e pelo 'caminho Net.' Eu diria que não, que provavelmente não é melhor declarar constantes nas interfaces. Tecnicamente, não é permitido em c #.

A razão pela qual digo não é que uma interface é uma forma de contrato que define comportamento, não estado ou estrutura. Uma constante implica algum tipo de estado (primitivo) ou um aspecto do estado (composto ou agregado).

Posso apreciar o desejo de disponibilizar padrões e valores predefinidos para todos que implementam a interface, mas talvez o estado padrão seja melhor descrito em um objeto ou modelo abstrato ou de valor, onde os padrões tenham pelo menos um contexto mínimo.

Para um guia mais técnico: download.oracle.com/javase/1.5.0/docs/guide/language/static-import.html

Não, não é uma prática ruim geral.

O ponto é que constantes como qualquer outro artefato devem ser introduzidas sob as regras de visibilidade mínima e nível de abstração adequado.

Usar a sintaxe apenas porque você pode é o verdadeiro problema.