Separando objetos utilizando classe de constantes

Preciso separar objetos Produto utilizando um atributo String.
Para isso utilizei uma classe com constantes. Essa é a melhor abordagem utilizando melhores praticas de OO?

public final class Constantes {

	public static final int TIPOA = 0;
	public static final int TIPOB = 1;
	public static final int TIPOC = 2;
        //mais
	...
	public static final List<String> LISTA_TIPO_A = Arrays.asList("aluminio","ferro","cobre");
	public static final List<String> LISTA_TIPO_B = Arrays.asList("cedro","eucalipto");
	public static final List<String> LISTA_TIPO_C = Arrays.asList("basalto","quartizito","granito");
	...
        //mais
}

Classe Produto

import static Constantes.*;
public class Produto {

	private int tipo = 0;
	private String material = null;

	public produto (String material){
                //Aqui vai o aluminio, basalto, ferro etc.
		this.material = material;
		setTipo(tipo);
	}
	public void setTipo() {
		if (Constantes.LISTA_TIPO_A.contains(this.material))
			 this.tipo = Constantes.TIPOA;		
		else if (Constantes.LISTA_TIPO_B.contains(this.material))
			 this.tipo = Constantes.TIPOB;
		//aqui ficam muitos if/else
                ...                
	}
}

Criei uma interface Identificador

//varios Identificadores, alterando-se o Constantes.TIPOA e o numero do retorno de getNumeroDaCaixa().
public class IdentificadorMadeira implements Identificador {

	public boolean suportaTipo(Produto produto) {
		return Constantes.TIPOA == objeto.getTipo() ? true : false;
	}
	//retorna o numero da caixa
	public int getNumeroDaCaixa(){
		return 1;
	}
}

Para separar os objetos em caixas(outro obj) uso uma classe que possui uma lista de todos Identificadores :

class IdentificadorFactory {  
  	List<Identificador> list;  
  	// Inicia a lista e adiciona as instancias de configuradores  
  	IdentificadorFactory() {  
    	..  
    		this.list.add(new IdentificadorMadeira());  
   		... // Mais instancias de configuradores  
  		}  
  	Identificador getIdentificador(int tipo) {  
    		// Faz um loop na lista de retorna o tipo especifico  
   		 if(identificador.suportaTipo(tipo)) {  
      		return identificador;  
    		}  
  	} 

Por fim, na Main:

	IdentificadorFactory identificadores = IdentificadorFactory.getInstancia();

	for (Produto p : produtos) {
		Identificador identificador = identificadores.getIdentificador(p);
		//pega o numero da caixa para entao adicionar o produto à ela.
		int numeroDaCaixa = identificador.getNumeroDaCaixa();
		//Arraylist caixas com objetos caixa.
		caixa = caixas.get(numeroDaCaixa));
		caixa.adicionar(p);
	}		

Essa modelagem utilizando constantes é boa? Existem outra para deixar o codigo mais elegante?

Muito Grato

cara,

o que eu te indicaria era so usar ENUM ao invez da sua classe Constante.

t+

Acredito que não ha nenhum problema em criar uma classe para agrupar suas constantes.

oque o amigo alissonvla, mencionou sobre o uso de enum eu inficaria no caso dessas constantes que são uma lista que vc fez, que siceramente foi a primeira vez que vi alguem fazendo constante dessa forma.
Da uma estudada em ENUM para fazer as constantes de listas, vc pode ganhar muito em reusabilidade .

Vou estudar enum.
muito obrigado.