enum inheritance, or something similar

I have a string (which is a message) th开发者_JS百科at I get as input and I need to do one of 4 possible things depending on the string I know that there is eunm.valueOf() option, but I have 4 different enums, each with few possible messages.

looks something like:

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
}

is it possible to do this in one method of the enum? or should I just try to create one, and if I get an exception try the other and so on?

As others have commented, it may be better to think through whether you really need 4 distinct enums.

But if you do, you could have them implement a common interface. Then you can map the input strings to the appropriate enum member, and call its method to accomplish what you want. Something like

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();
  }
}

This assumes that the 4 possible things you want to do correspond to the 4 enums. If not, you can override the method separately for each and any enum member too, e.g.

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 }
};

Enumerations in Java are full blown classes. Individual values can even override the behavior to meet their needs. It's pretty cool. You can use this to your advantage:

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);
}

You can create a Map of them all

 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);

What you're really looking for is a aggregation of the other enums. The easiest way to get that is to make a new enum that puts all of those choices in a new enum. Something to this effect:

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;
    }
}

This will more correctly aggregate the previous enums into a single data structure.

Even given your odd/even example in the comments, I don't feel multiple enums are the way to go here. I would use something like (warning, untested):

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; }
}

Then you can use valueOf() to look up the enum element, and getType() to find out which of your three categories it belongs to.

It isn't entirely clear what you are asking, but perhaps you want to define a mapping between strings and constants, like this:

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);
}