jpprogrammer,
a sua solução parece ser muito boa. Baseado nela, eu criei uma interface chamada TipoConstanteInterface, uma classe abstrata chamada TipoConstanteAbstrata que implementa TipoConstanteInterface, e finalmente a classe que extende a classe abstrata e aonde está definido as constantes, chamada TipoDocumentoIdentidade.
Abaixo segue o código da interface e das classes que criei:
/* Interface TipoConstanteInterface. */
import java.util.List;
public interface TipoConstanteInterface {
public String getCodigo();
public String getDescricao();
public List listar();
public boolean equals(Object object);
}
/*
* Classe abstrata TipoConstanteAbstrata, que implementa a interface
* TipoConstanteInterface.
*/
public abstract class TipoConstanteAbstrata implements TipoConstanteInterface {
private String codigo;
private String descricao;
/**
*
*/
public TipoConstanteAbstrata(String codigo, String descricao) {
this.codigo = codigo;
this.descricao = descricao;
}
/* (non-Javadoc)
* @see br.com.abnc.detnet.renach.dal.interfaces.TipoConstanteInterface#getCodigo()
*/
public String getCodigo() {
return codigo;
}
/* (non-Javadoc)
* @see br.com.abnc.detnet.renach.dal.interfaces.TipoConstanteInterface#getDescricao()
*/
public String getDescricao() {
return descricao;
}
/* (non-Javadoc)
* @see br.com.abnc.detnet.renach.dal.interfaces.TipoConstanteInterface#equals()
*/
public boolean equals(Object object) {
if ((object != this) || (!(object instanceof TipoConstanteAbstrata))) {
return false;
} else {
TipoConstanteAbstrata tipoConstante = (TipoConstanteAbstrata) object;
if (this.codigo.equals(tipoConstante.codigo)) {
return true;
} else {
return false;
}
}
}
}
/*
* Classe TipoDocumentoIdentidade que herda de
* TipoConstanteAbstrata.
*/
public class TipoDocumentoIdentidade extends TipoConstanteAbstrata {
public static final TipoConstanteAbstrata CARTEIRA_INDENTIDADE =
new TipoDocumentoIdentidade("0", "Carteira de Identidade");
public static final TipoConstanteAbstrata CARTEIRA_PROFISSIONAL =
new TipoDocumentoIdentidade("1", "Carteira Profissional");
public static final TipoConstanteAbstrata PASSAPORTE =
new TipoDocumentoIdentidade("2", "Passaporte");
public static final TipoConstanteAbstrata CARTEIRA_RESERVISTA =
new TipoDocumentoIdentidade("3", "Carteira de Reservista");
/**
* @param codigo
* @param descricao
*/
public TipoDocumentoIdentidade(String codigo, String descricao) {
super(codigo, descricao);
}
/* (non-Javadoc)
* @see br.com.abnc.detnet.renach.dal.interfaces.TipoConstanteInterface#listar()
*/
public List listar() {
List listaDocumentos = new ArrayList();
listaDocumentos.add(CARTEIRA_INDENTIDADE);
listaDocumentos.add(CARTEIRA_PROFISSIONAL);
listaDocumentos.add(PASSAPORTE);
listaDocumentos.add(CARTEIRA_RESERVISTA);
return listaDocumentos;
}
}
Fiz desta forma para ficar o mais genérico possível. Por exemplo, eu necessitarei carregar comboboxs em minhas páginas contendos o valor destas constantes. Da forma que defini, poderei criar uma custontag que realize este preenchimento, e que não necessitará conhecer o valor que deverá preencher, pois ela acessará na verdade a interface. Já a classe abstrata implementa os métodos comuns de todas as classes de constantes, como carregar o codigo e descricao no construtor, resgatar o codigo ou a descricao, e realizar a comparação de igualdade entre os objetos.
E então, você acha que desta forma está bem implementado, ou poderia ser melhorado?
Assim, estou definindo uma interface padrão que poderá ser utilizada, por exemplo, numa custon tag que deverá fazer o preenchimento de um determinado combobox, mais não sabe qual tipo de valor constante deverá capturar, e uma classe abstrata que
- EDIT - Por favor, ponham os tags [ code ] -
