enumeraciones compartían método estático de consulta

Question

tengo la siguiente enumeración:

public enum MyEnum{ 
    A(10, "First"), // 
    B(20, "Second"), // 
    C(35, "Other options"); 

    private Integer code; 
    private String description; 

    private MyEnum(Integer code, String description) { 
     this.code = code; 
     this.description = description; 
    } 

    public Integer getCode() { 
     return code; 
    } 

    public String getDescription() { 
     return description; 
    } 

    public static MyEnum getValueOf(Integer code) { 
     for (MyEnum e : MyEnum.values()) { 
      if (e.getCode().equals(code)) { 
       return e; 
      } 
     } 
     throw new IllegalArgumentException("No enum const " + MyEnum.class.getName() + " for code \'" + code 
       + "\'"); 
    } 
} 

que funciona muy bien. El método getValueOf existe porque cuando nos comunicamos con un socio externo, solo obtenemos el código (que eligieron) para mapear. Necesito la descripción porque necesito mostrar una frase significativa en la GUI.

Pero ahora tengo un número de clases enum similares. Todos tienen su propia descripción de código &, y necesitan la misma funcionalidad de búsqueda. Quería que el método getValueOf fuera genérico, así que no necesito admitir más de 30 enumeraciones diferentes para básicamente el mismo método.

Para resolver esto, quería hacer una clase abstracta para definir este método e implementar algunas de las lógicas comunes, pero esto es imposible porque no puedo extender Enum.

Luego trató de hacer una clase de servicio con el siguiente método:

public static <T extends Enum<T>> T getValueOf(Enum<T> type, Integer code) {...} 

Pero los genéricos con enumeraciones son confusas y no entiendo cómo conseguir este trabajo.

Básicamente lo que quiero saber es: ¿Cuál es un buen enfoque para definir una utilidad común para una enumeración?

Answer 1

Debe pasar el objeto de la clase enum real como parámetro de su método. Luego puede obtener los valores enum usando Class.getEnumConstants().

Con el fin de poder acceder a la getCode() de los casos, debe definirlo en una interfaz y hacer todos sus tipos de enumeración implementan esa interfaz:

interface Encodable { 
    Integer getCode(); 
} 

public static <T extends Enum<T> & Encodable> T getValueOf(Class<T> enumClass, Integer code) { 
    for (T e : enumClass.getEnumConstants()) { 
     if (e.getCode().equals(code)) { 
      return e; 
     } 
    } 
    throw new IllegalArgumentException("No enum const " + enumClass.getName() + " for code \'" + code 
      + "\'"); 
} 

... 

public enum MyEnum implements Encodable { 
    ... 
} 

MyEnum e = getValueOf(MyEnum.class, 10); 

Answer 2

Esto es un poco complicado ya que el método values() es estático. En realidad, necesitaría reflexión, pero hay una buena manera de ocultar esto utilizando la funcionalidad de biblioteca estándar.

En primer lugar, definir una interfaz con los métodos comunes a todos los tipos de enumeración:

public interface Common { 
    Integer getCode(); 
    String getDescription(); 
} 

A continuación, haz todas sus enumeraciones implementan esta interfaz:

public enum MyEnum implements Common {...} 

El método estático que desea tener entonces se parece a:

public static <T extends Enum<T> & Common> T getValueOf(Class<T> type, Integer code) { 
    final EnumSet<T> values = EnumSet.allOf(type); 
    for(T e : values) { 
     if(e.getCode().equals(code)) { 
      return e; 
     } 
    } 
    throw new IllegalArgumentException("No enum const " + type.getName() + " for code \'" + code + "\'"); 
}