Java-Enums: Zwei enum-Typen, jeweils mit verweisen auf die jeweils anderen?

Einer der besten Wege, mit Hilfe der enum-Polymorphismus-Technik:

public class EnumTest {
    public enum Foo {
        A {

            @Override
            public Bar getBar() {
                return Bar.Alpha;
            }
        },
        B {

            @Override
            public Bar getBar() {
                return Bar.Delta;
            }
        },
        C {

            @Override
            public Bar getBar() {
                return Bar.Alpha;
            }
        },

        ;

        public abstract Bar getBar();
    }

    public enum Bar {
        Alpha {

            @Override
            public Foo getFoo() {
                return Foo.A;
            }
        },
        Beta {

            @Override
            public Foo getFoo() {
                return Foo.C;
            }
        },
        Delta {

            @Override
            public Foo getFoo() {
                return Foo.C;
            }
        },

        ;

        public abstract Foo getFoo();
    }

    public static void main(String[] args) {
        for (Foo f : Foo.values()) {
            System.out.println(f + " bar " + f.getBar());
        }
        for (Bar b : Bar.values()) {
            System.out.println(b + " foo " + b.getFoo());
        }
    }
}

Der obige code erzeugt die Ausgabe, die Sie wollen:

A bar Alpha
B bar Delta
C bar Alpha
Alpha foo A
Beta foo C
Delta foo C

Siehe auch:

• Overridding Methode eines bestimmten enum

InformationsquelleAutor falsarella

Da es scheint, dass Sie gehen, um hart zu codieren sowieso, warum nicht so etwas wie

public static Bar responseBar(Foo f) {
 switch(f) {
  case A: return Bar.Alpha;
  //... etc
 }
}

für jede enum? Es sieht aus wie Sie einige überlappende Reaktionen in deinem Beispiel, so könnte man auch nutzen Fällen fallen durch.

EDIT:

Mag ich Tom ' s Vorschlag, die EnumMap; ich denke Leistung ist wahrscheinlich schneller auf die EnumMap, aber die Art von elegante Konstruktion beschrieben, in der Effektiven Java scheint nicht zu sein, die sich durch dieses bestimmte problem - aber die switch-Lösung angeboten oben wäre ein guter Weg, um zu konstruieren, die zwei statische EnumMaps, dann ist die Antwort könnte so etwas wie:

 public static Bar response(Foo f) { return FooToBar.get(f); }
 public static Foo response(Bar b) { return BarToFoo.get(b); }

InformationsquelleAutor Carl

Können Sie EnumMap, und füllen Sie es in eine der Enumerationen.

private static EnumMap<Foo, LinkedList<Bar>> enumAMap;

public static void main(String[] args) throws Exception {
    enumAMap = new EnumMap<Foo, LinkedList<Bar>>(Foo.class);
    System.out.println(Bar.values().length); //initialize enums, prevents NPE
    for (Foo a : Foo.values()) {
        for (Bar b : enumAMap.get(a)) {
            System.out.println(a + " -> " + b);
        }
    }
}

public enum Foo {
    Foo1(1),
    Foo2(2);

    private int num;

    private Foo(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

public enum Bar {
    Bar1(1, Foo.Foo1),
    Bar2(2, Foo.Foo1),
    Bar3(3, Foo.Foo2),
    Bar4(4, Foo.Foo2);

    private int num;
    private Foo foo;

    private Bar(int num, Foo foo) {
        this.num = num;
        this.foo = foo;
        if (!enumAMap.containsKey(foo)) {
            enumAMap.put(foo, new LinkedList<Bar>());
        }
        enumAMap.get(foo).addLast(this);
    }

    public int getNum() {
        return num;
    }

    public Foo getFoo() {
        return foo;
    }
}

Ausgabe:

4
Foo1 -> Bar1
Foo1 -> Bar2
Foo2 -> Bar3
Foo2 -> Bar4

InformationsquelleAutor MForm