Java Énumérations: Deux types d'énumérations, chacun contenant des références à l'autre?

L'un des meilleurs moyens d'y parvenir consisterait à l'aide de la enum polymorphisme technique:

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

Le code ci-dessus génère la sortie que vous souhaitez:

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

Voir aussi:

• Overridding méthode spécifique d'un enum

Puisqu'il semble que vous allez être de codage en dur, de toute façon, pourquoi ne pas avoir quelque chose comme

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

pour chaque enum? Il semble que vous avez un certain chevauchement des réponses dans votre exemple, vous pourriez même profiter des cas de tomber à travers.

EDIT:

J'aime Tom à la suggestion de la EnumMap; je pense performance est probablement plus rapide sur le EnumMap, mais le genre de l'élégante construction décrite dans l'efficacité de Java ne semble pas être accordée par ce problème particulier - toutefois, le commutateur solution proposée ci-dessus serait un bon moyen de construire deux statique EnumMaps, la réponse pourrait être quelque chose comme:

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

Vous pouvez utiliser EnumMap, et de le remplir au sein de l'un des enums.

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

De sortie:

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