enums avec références croisées

Version imprimable

Bonjour,
Quelque chose m'échappe dans le processus d'instanciation des enum.
J'ai deux enum différentes, chacune possède des attributs du type de l'autre, et l'une des deux ne se construit pas correctement.
Exemple simplifié :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 public class Test { private static enum E1 { A(E2.A), B(E2.B); public E2 e2; private E1(E2 e2) { this.e2 = e2; } } private static enum E2 { A(E1.A), B(E1.B); public E1 e1; private E2(E1 e1) { this.e1 = e1; } } public static void main(String[] args) { for (E1 e1 : E1.values()) { System.out.print(e1.e2 + "\n"); } for (E2 e2 : E2.values()) { System.out.print(e2.e1 + "\n"); } } }
renvoie :
A
B
null
null

Pourtant, pas d'erreur à la compilation. Est-ce que ce mécanisme est licite ? Il y a-t-il un moyen de contourner cela ?

Merci pour votre aide.

05/07/2010, 18h41
adiGuba
Salut,

C'est normal car tu es croisés dans les 2 sens. E1 a besoin de E2 qui a lui-même besoin de E1...

A l'initialisation il y a forcément un moment où un des champs n'est pas encore valide :
- Tu charges l'enum E1, et donc cela crée les attributs static A & B non initialisé (=null).
- Les champs static A & B sont initialisés. Donc cela appelle le constructeur E1()
- Ce dernier charge l'enum E2, qui utilisent l'enum E1 alors qu'elle n'est pas encore totalement initialisé, et tu récupères donc les valeurs nulles.
- Les constructeurs de E1 sont finalement exécutés, et la classe E1 est enfin correctement initialisé, mais tu accèdes aux données trop tôt.
:arrow: Quelle est la raison qui t'amène à un tel croisement ?

a++

PS : Et attention aux attributs public dans les enums. Ces dernières devrait logiquement être immuable...
05/07/2010, 19h46
lnotray

Citation:

Quelle est la raison qui t'amène à un tel croisement ?

Je voulais utiliser quelque chose de ce genre pour diviser un groupe d'éléments en sous-groupes.
Comme le groupe principal et les sous-groupes sont finis et figés, je trouvais logique d'utiliser des enum :

Enum A Enum B
- A1 \
- A2 -----B1
- A3 /

- A4 \
- A5 -----B2
- A6 /

- A7 \
- A8 -----B3
- A9 /

Problème si je veux à partir de A4 retrouver les frères A5 et A6 je suis obligé de déclarer A dans B et B dans A.
De ce que tu dis ça ne me paraît pas possible de cette façon.
Merci à toi.

Citation:

Envoyé par lnotray

Problème si je veux à partir de A4 retrouver les frères A5 et A6 je suis obligé de déclarer A dans B et B dans A.

Ben il te suffit de donner le lien dans un sens seulement. Par exemple uniquement en liant le parent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public enum B {
    B1, B2, B3;
}
 
 
 
public enum A {
    A1(B1), A2(B1), A3(B1),
    A4(B2), A5(B2), A6(B2),
    A7(B3), A8(B3), A9(B3);
 
    private B parent;
 
    private A(B parent) {
        this.parent = parent;
    }
 
    public static static List<A> getByParent(B b) {
        ArrayList<A> list = new ArrayList<A>();
        foreach (A a : A.values()) {
            if (a.parent==b) {
                list.add(a);
            }
        }
        list.trimToSize();
        return list;
    }
}

a++

05/07/2010, 21h11
lnotray

ça se tient, merci.
je pensais qu'il existait quelque chose de plus esthétique.

En fait après réflexion je préfère cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
public class Test {
	private static enum E1 {
		A {
			@Override
			public E2 getE2() {
				return E2.A;
			}
		},
		B {
			@Override
			public E2 getE2() {
				return E2.B;
			}
		};
		public abstract E2 getE2();
	}
 
	private static enum E2 {
		A {
			@Override
			public E1 getE1() {
				return E1.A;
			}
		},
		B {
			@Override
			public E1 getE1() {
				return E1.B;
			}
		};
		public abstract E1 getE1();
	}
 
	public static void main(String[] args) {
		for (E1 e1 : E1.values()) {
			System.out.println(e1.getE2());
		}
		for (E2 e2 : E2.values()) {
			System.out.println(e2.getE1());
		}
	}
}

Comme cela on n'a plus besoin de se préoccuper de l'ordonnancement des constructeurs, puisqu'ils n'ont plus d'argument (je ne savais pas que c'était possible).

06/07/2010, 11h45
tchize_

a ben m***** et moi qui avait appris que les enum étaient d'office final et donc ne pouvaient pas etre sous classés, tu m'en apprend une bonne là :mouarf: