在枚举中枚举

Question

这不是一个被卡住的问题，而是我正在寻找一种整洁的方式来编写我的代码。

本质上，我正在编写一个事件驱动的应用程序。用户触发事件，事件被发送到适当的对象，并且对象处理事件。现在我正在编写偶处理程序方法，并且希望能够使用switch语句来确定如何处理事件。现在，虽然我工作的总体结构，事件类是非常简单的：

public class Event { 

    public static enum Action { 
     MOVE, FOO, BAR 
    } 

    private Action action; 
    private int duration; 

    public Event(Action action, int duration) { 
     this.action = action; 
     this.duration = duration; 
    } 

    public Action getAction() { 
     return action; 
    } 

    public int getDuration() { 
     return duration; 
    } 

然后，在另一个类，我会碰到这样的：

public void handleEvent(Event evt) {  
    switch(Event.getAction()) { 
     case MOVE: doSomething(); break; 
     case FOO: doSomething(); break; 
     case BAR: doSomething(); break; 
     default: break; 
    } 
} 

我会像做的就是这样的事情（尽管我当然会坚持开关语句转换成自己的职能，以避免它变成开关和案例讨厌的毛球）：

public void handleEvent(Event evt) {  
    switch(Event.getAction()) { 
     case MOVE: switch(Event.getAction()) { 
         case UP: break; 
         case DOWN: break; 
         case LEFT: break; 
         case RIGHT: break; 
        } 
     case FOO: break; 
     case BAR: break; 
     default: break; 
    } 
} 

所以，我想创建嵌套枚举......像这样：

public static enum Action { 
    public enum MOVE {UP, DOWN, LEFT, RIGHT}, FOO, BAR 
} 

它不象我无法回避的情况下，这纯粹是...方便。因此，尽管上述方法实际上并不奏效，但是有没有类似的方法来实现这一点？如果我可以用动作“MOVE.UP”发送一个事件，并且该方法首先将其识别为MOVE类型的动作，然后进一步确定它具体处于UP方向，那将会很好。这只是一个简单的例子，如果我也可以制作更长的连锁店，比如“DELETE.PAGE1.PARAGRAPH2.SENTENCE2.WORD11.LETTER3”，那就更好了。我看到它的方式，我将不得不使用字符串和大量的if/else语句。希望有更好的办法！ （哦，和性能事关我的情况下，如果有帮助）

Answer 1

也许使用事件的继承层次？

所以，你必须：

- abstract Event 
-- MoveEvent(Direction) 
-- FooEvent() 
-- BarEvent() 

它可能更有意义有：

- abstract Event 
-- abstract MoveEvent 
--- MoveUpEvent 
--- MoveDownEvent 
--- MoveRightEvent 
--- MoveLeftEvent 
-- FooEvent 
-- BarEvent 

如果所有的移动事件有一段距离，然后传递到MoveEvent构造函数（这将波及下）。

Answer 2

我相信在Java中，只要你的非枚举常量是第一位的，你可以简单地嵌套枚举。

enum Action 
{ 
    FOO, 
    BAR; 
    enum MOVE 
    { 
     UP, 
     DOWN, 
     LEFT, 
     RIGHT 
    } 
} 

这个编译给我，并给我你正在寻找的行为。

Answer 3

你可以像这样以任意顺序嵌套它们：

包嵌套;

import java.util.*; 
import nested.Citrus.Orange; 
interface HasChildren { 
    Set<Enum<?>> children(); 
} 
enum Citrus implements HasChildren { 
    lemon, lime, orange; 
    Set<Enum<?>> children; 
    enum Orange implements HasChildren { 
     navel, valencia, blood; 
     Set<Enum<?>> children; 
     enum Navel implements HasChildren { 
      washinton, lateLane, caraCaraPink; 
      public Set<Enum<?>> children() { 
       return null; 
      } 
     } 
     static { 
      navel.children = new LinkedHashSet<Enum<?>>(); 
      navel.children.addAll(EnumSet.allOf(Navel.class)); 
     } 
     enum Blood implements HasChildren { 
      moro, taroco; 
      public Set<Enum<?>> children() { 
       return null; 
      } 
     } 
     static { 
      blood.children = new LinkedHashSet<Enum<?>>(); 
      blood.children.addAll(EnumSet.allOf(Blood.class)); 
     } 
     public Set<Enum<?>> children() { 
      return children != null ? Collections.unmodifiableSet(children) : null; 
     } 
    } 
    static { 
     orange.children = new LinkedHashSet<Enum<?>>(); 
     orange.children.addAll(EnumSet.allOf(Orange.class)); 
    } 
    public Set<Enum<?>> children() { 
     return children != null ? Collections.unmodifiableSet(children) : null; 
    } 
} 
public class EnumTreeNested { 
    static void visit(Class<?> clazz) { 
     Object[] enumConstants = clazz.getEnumConstants(); 
     if (enumConstants[0] instanceof HasChildren) for (Object o : enumConstants) 
      visit((HasChildren) o, clazz.getName()); 
    } 
    static void visit(HasChildren hasChildren, String prefix) { 
     if (hasChildren instanceof Enum) { 
      System.out.println(prefix + ' ' + hasChildren); 
      if (hasChildren.children() != null) for (Object o : hasChildren.children()) 
       visit((HasChildren) o, prefix + ' ' + hasChildren); 
     } else 
      System.out.println("other " + hasChildren.getClass()); 
    } 
    static <E extends Enum<E> & HasChildren> Set<E> foo() { 
     return null; 
    } 
    public static void main(String[] args) { 
     System.out.println(Citrus.Orange.Navel.washinton); 
     visit(Citrus.lemon, ""); 
     System.out.println("----------------------"); 
     visit(Citrus.orange, ""); 
     System.out.println("----------------------"); 
     visit(Citrus.class); 
     System.out.println("----------------------"); 
    } 
}