herencia enum, o algo similar

Question

Tengo una cadena (que es un mensaje) que obtengo como entrada y tengo que hacer una de 4 cosas posibles dependiendo de la cadena Sé que hay una opción eunm.valueOf() , pero tengo 4 enumeraciones diferentes, cada una con pocos mensajes posibles.

se ve algo como:

public enum first{ONE,TWO,THREE}; 
public enum second{FOUR,FIVE,SIX}; 
public enum third{SEVEN,EIGHT,NINE}; 

public void work(String message){ 
    //Here I want to compare message string to one of the 3 enums 
} 

es posible hacer esto en un método de la enumeración? o debería tratar de crear uno, y si obtengo una excepción, pruebo el otro y así sucesivamente?

Answer 1

Como han comentado otros, puede ser mejor pensar si realmente necesita 4 enumeraciones distintas.

Pero si lo hace, podría hacer que implementen una interfaz común. Luego puede asignar las cadenas de entrada al miembro enum apropiado y llamar a su método para lograr lo que desea. Algo como

public interface SomeInterface { 
    void doSomething(); 
}; 

public enum First implements SomeInterface { 
    ONE,TWO,THREE; 
    @Override 
    public void doSomething() { ... } 
}; 
... 
Map<String, SomeInterface> myMap = new HashMap<String, SomeInterface>(); 
for (First item : First.values()) { 
    myMap.put(item.toString(), item); 
} 
... 

public void work(String message){ 
    SomeInterface obj = myMap.get(message); 
    if (obj != null) { 
    obj.doSomething(); 
    } 
} 

Esto supone que las 4 cosas posibles que desea hacer corresponden a las 4 enumeraciones. De lo contrario, puede anular el método por separado para cada miembro enum también, p.

public enum First implements SomeInterface { 
    ONE, 
    TWO { 
    @Override 
    public void doSomething() { // do something specific to TWO } 
    }, 
    THREE; 
    @Override 
    public void doSomething() { // general solution for all values of First } 
}; 

Answer 2

Lo que realmente está buscando es una agregación de las otras enumeraciones. La forma más fácil de obtenerlo es crear un nuevo enum que coloque todas esas opciones en un nuevo enum. Algo en este sentido:

public enum Combination { 
    NEWONE(first.ONE), NEWTWO(first.TWO), NEWTHREE(first.THREE), 
    NEWFOUR(second.FOUR), NEWFIVE(second.FIVE), NEWSIX(second.SIX), 
    NEWSEVEN(third.SEVEN), NEWEIGHT(third.EIGHT), NEWNINE(third.NINE); 

    private String contents; 

    public Combination(first f) { 
     contents = f.toString(); 
    } 

    public Combination(second s) { 
     contents = s.toString(); 
    } 

    public Combination(third t) { 
     contents = t.toString(); 
    } 

    public String toString() { 
     return contents; 
    } 
} 

Esto agregará más correctamente las enumeraciones anteriores en una sola estructura de datos.

Answer 3

Enumeraciones en Java son clases completas. Los valores individuales pueden incluso anular el comportamiento para satisfacer sus necesidades. Es genial. Usted puede usar esto para su ventaja:

public enum Value implements Worker 
{ 
    ONE, 
    TWO, 
    THREE 
    { 
     @Override 
     public void doWork(String message) 
     { 
      // overrides behavior of base enum 
     } 
    }, 
    FOUR, 
    /* ... */, 
    NINE; 

    private final String message; 

    Value() { this(""); } 
    Value(String message) { this.message = message; } 

    public void doWork(String message) 
    { 
     if (this.message.equals(message)) 
     { 
      /* ... */ 
     } 
    } 
} 

public interface Worker 
{ 
    void doWork(String message); 
} 

Answer 4

No está del todo claro lo que están pidiendo, pero tal vez desee definir una correspondencia entre cadenas y constantes, así:

enum Type { FIRST, SECOND, THIRD }; 
Map<String, Type> mapping = new HashSet<String, Type>(){{ 
    put("ONE", Type.FIRST); 
    put("TWO", Type.FIRST); 
    //... 
    put("NINE", Type.THIRD); 
}}; 

public Type getTypeFromString(String s) { 
    return mapping.get(s); 
} 

Answer 5

Incluso dado su ejemplo impar/par en los comentarios, no creo que las enumeraciones múltiples sean el camino a seguir aquí. Me gustaría utilizar algo así como (advertencia, no probado):

public enum Numbers { 
ONE("first"), TWO("first"), THREE("first"), FOUR("second"), FIVE("second"), SIX("second"), SEVEN("third"), EIGHT("third"), NINE("third") 

private String type; 

Numbers(String t) { this.type = t; } 
String getType { return this.type; } 
} 

continuación, puede utilizar valueOf() para buscar el elemento de enumeración, y getType() para averiguar cuál de sus tres categorías que pertenece.

Answer 6

Se puede crear un mapa de todos

static final Map<String, Enum> enumMap = new LinkedHashMap<String, Enum>(){{ 
    for(First e: First.values()) put(e.name(), e); 
    for(Second e: Second.values()) put(e.name(), e); 
    for(Third e: Third.values()) put(e.name(), e); 
}}; 

Enum e = enumMap.get(name);