web-dev-qa-db-ja.com

列挙内の列挙

これは私が立ち往生しているという問題ではなく、むしろコードを書くための整然とした方法を探しています。

基本的に、イベント駆動型のアプリケーションを作成しています。ユーザーがイベントをトリガーし、イベントが適切なオブジェクトに送信され、オブジェクトがイベントを処理します。現在、偶数ハンドラーメソッドの作成に取り組んでおり、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; 
    }
}

私がすることlikeは次のようなものです（もちろん、switchステートメントを独自の関数に固定して、スイッチやケースの厄介なヘアボールにならないようにします）：

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ステートメントを使用する必要があります。より良い方法があることを願っています！ （ああ、私の場合はパフォーマンスが重要です、それが役立つ場合）

javaenumsnested
29
Fault

おそらくイベントに継承階層を使用しますか？

だからあなたが持っています：

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

持っているほうが理にかなっているかもしれません：

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

すべてのMoveイベントに距離がある場合、それをMoveEventコンストラクターに渡します（これは波紋します）。

7
Dan Hardiker

Javaでは、列挙型でない定数が最初に来る限り、enumを単純にネストできると思います。

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

これは私のためにコンパイルされ、あなたが探していた動作を私に与えます。

32
Patrick Perini

次のように任意の順序でネストできます。

ネストされたパッケージ。

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("----------------------");
    }
}
3
Ray Tayek