Certa vez me disseram que não é bom se ter constantes declaradas em interfaces, e a esplicação acabou ficando ao bom e velho “porque Deus quis”.
Enfim: É ruim declarar constantes em interfaces? Por quê?
Valeu pelo texto indicado, mas ele não mostra nenhum argumento mais sólido nem a favor, nem contra.
E, no meu caso, é intencional as constantes fazerem parte da API pública.
O que me dizem?
Sim, segundo o texto, interfaces deveriam so conter somente os “servicos” que serao disponibilizados pela classe que a implementa. Uma melhor solucao seria implementar uma classe com constantes estaticas. Um exemplo que ele deu no texto eh a classe Math, que tem o Math.PI
Aqui esta o exemplo de classe de constantes
http://www.javapractices.com/topic/TopicAction.do?Id=2
Pensando bem acho que faz sentido, eu mesmo ja defini muita constante em interfaces. :oops:
//Daniel
[quote=Mantu]Certa vez me disseram que não é bom se ter constantes declaradas em interfaces, e a esplicação acabou ficando ao bom e velho “porque Deus quis”.
Enfim: É ruim declarar constantes em interfaces? Por quê?[/quote]
No passado era muito utilizado. Depois alguem criou o padrão Enum (suas variantes Int Enum e String Enum)
porque colocar constantes em interfaces é ruim. Depois vieram os Enum no java 5 que constroem o padrão enum de forma intrinseca na linguagem e na jvm.
Declarar constantes em interfaces sempre foi ruim , mas houve um tempo em que não havia alternativa.
Hoje, existe alternativa , e muito melhor. Use Enum.
[quote=sergiotaborda]Declarar constantes em interfaces sempre foi ruim , mas houve um tempo em que não havia alternativa.
Hoje, existe alternativa , e muito melhor. Use Enum. [/quote]
Eu acabei usando Enum mesmo ontem a noite. Valeu pela dica.
Mas, agora, por que é e sempre foi ruim colocar constantes em interfaces? Há algum outro motivo além de tornalas parte da API pública da interface?
Isso foi sempre um abuso da especificação - constantes em interfaces é um recurso “deprecated”.
Algumas coisas do Java 1.0 são assim (constantes em interfaces, em vez de usar enums, e falta de generics), segundo o sr. James Gosling, por falta de tempo mesmo.
O que você não pode fazer é ficar como seu professor, que aprendeu Java na versão 1.0 e nunca mais se atualizou - pode ser que ele ache que applets são o recurso mais moderno da Internet, por exemplo.
Desculpem ser chato, mas por quê, exatamente, é um abuso da especificação? Quais são os efeitos colaterais de se ter constantes em interfaces? Ou não se deve usa-las lá tão somente porque a especificação não foi explicita quanto a tal uso?
É assim: na maior parte das linguagens que têm um recurso parecido com o de interfaces (como C++ que tem classes abstratas), não existe esse tal recurso de constantes fazendo parte da interface. Se algo é diferente das outras linguagens aparentadas (como C ou Algol), é para ter alguma razão.
Pelo que imagino, não houve tempo de criar uma “enum” do jeito certo (na verdade o Gosling até esqueceu de deixar reservada essa palavra-chave, o que deu problemas depois), e era bem mais simples aceitar que interfaces tivessem membros “public static final”. Uma verdadeira “enum” talvez implicasse (naquele tempo) em ter um tipo de arquivo .class um pouco diferente, e outras interações chatas.
E é por isso que apareceu tal coisa, que na verdade é um quebra-galho.
pelo visto o mantu ta querendo uma resposta mais concreta, e não uma resposta decorada da galera que aprendeu assim ai saí repetindo(não me xinguem sei que eu sou mero noob : D ) , porem mantu eu acho que a coisa é mesmo so por aí não um motivo técnico para não hà por constantes em interfaces(creio eu porque não sei como ficam esses dados na memoria e como a jvm acessa eles) é simplismente para seguir um padrão de não ficar misturando as coisas é somente uma organização, coisas parecidas você agrupa certo ? você não poe um livro na prateleira de trofeus , voce poe prateleira de livros , certo ? ahhah não sou muito bom com exemplos =x
Também acredito que seja para padronizar. COmo, por exemplo, criar métodos com a primera letra minúscula e com letras maiúsculas no início de cada palava… Nada impede de se usar os métodos com nomes todos em maiúsculas e com as palavras separdas por underlines… e o desempenho não muda… :lol:
Quando comecei a programar, achava o máximo lotar uma interface de constantes, dar um “implements qualquercoisa” e voilá, já tá disponível para uso.Sei lá, acho que o próprio contrato que se faz com uma interface(e o que a classe que a implementa deve fazer), já prevê, uma suposta “mutabilidade” do código da classe que implementa seus métodos.Uma constante, como o nome diz, dificilmente será mudada.
Uso Enum, em geral, quando preciso validar algo.Uso uma classe de constantes, quando são constantes meramente numéricas ou que guardam configuração de alguma coisa.Mas acho que vai de cada um… 
Constantes são ruins, independente de estarem em interfaces ou classes. Elas tem tipagem fraca (é tudo int ou String) e não-OO (essa constante não se refere a um domínio de negócio que possui ações associadas?), e normalmente está lá para ser usado em blocos switch, o inimigo número um do polimorfismo.
O melhor mesmo é usar enum. O programa não compila quando coloca um número qualquer no lugar da constante, e se houver métodos associado às constante, basta declarar dentro do enum.
O problema é que ao implementar a interface vc ganha de bonus todas as constantes.
Por exmeplo
interface StateMachine {
int EstadoA = 0;
int EstadoB = 1;
int getStatus();
boolean isInStatus(int status);
}
class MyStateMachine implements StateMachine {
// implementação
}
// Uso
MyStateMachine m = mew MyStateMachine ();
m.isInStatus(MyStateMachine.EstadoA); // errado
m.isInStatus(StateMachine.EstadoA); // certoO Java não diferencia se vc está chamando a constante na interface ou na classe que a implementa.
Quando vc define um EstadoC na propria classe de implementação (nada o impede) - o que é errado - vira tudo uma confusão. O compilador, coitado, não pode ajudar em nada.
[quote=sergiotaborda][quote=Mantu]Certa vez me disseram que não é bom se ter constantes declaradas em interfaces, e a esplicação acabou ficando ao bom e velho “porque Deus quis”.
Enfim: É ruim declarar constantes em interfaces? Por quê?[/quote]
No passado era muito utilizado. Depois alguem criou o padrão Enum (suas variantes Int Enum e String Enum)
porque colocar constantes em interfaces é ruim. Depois vieram os Enum no java 5 que constroem o padrão enum de forma intrinseca na linguagem e na jvm.
Declarar constantes em interfaces sempre foi ruim , mas houve um tempo em que não havia alternativa.
Hoje, existe alternativa , e muito melhor. Use Enum. [/quote]
mas e se eu fosse quisesse herdar de outras constantes?
Dona Maria, não use recursos antigos, e não herde (ou implemente, que é o nome correto disso quando se usam interfaces) só porque você tem preguiça.
Dentro da medida do possível, evite a herança a menos que faça sentido (e no caso específico de constantes em interfaces, não faz sentido).
O problema é que ao implementar a interface vc ganha de bonus todas as constantes.
Por exmeplo
interface StateMachine {
int EstadoA = 0;
int EstadoB = 1;
int getStatus();
boolean isInStatus(int status);
}
class MyStateMachine implements StateMachine {
// implementação
}
// Uso
MyStateMachine m = mew MyStateMachine ();
m.isInStatus(MyStateMachine.EstadoA); // errado
m.isInStatus(StateMachine.EstadoA); // certoO Java não diferencia se vc está chamando a constante na interface ou na classe que a implementa.
Quando vc define um EstadoC na propria classe de implementação (nada o impede) - o que é errado - vira tudo uma confusão. O compilador, coitado, não pode ajudar em nada.[/quote]
por curiosidade (e meio que falta de tempo agora, me desculpem), ja que reviveram o tópico mesmo, isso que o sergiotaborda postou me criou uma duvida… e seu eu faço uma “herança multipla de constantes das interfaces”? tipo, eu posso implementar várias interfaces, e se duas delas tiverem constantes com o mesmo nome e valor diferente? não compila, fica o valor da primeira na classe, na ultima, como que fica?
qualquer coisa se ninguém souber depois eu faço um teste e posto a conclusão aqui…