Enum, question héritage!

Version imprimable

Bonjour,

Voici mon problème, j'ai un liste d'enum qui ont des méthodes similaires :
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 public static enum TestEnum1 { TEST("test 1"), TEST2("test2"); private String name; private TestEnum1(String name){ this.name = name; } public String getName(){ return name; } } public static enum TestEnum2 { TEST3("test 3"), TEST4("test4"); private String name; private TestEnum2(String name){ this.name = name; } public String getName(){ return name; } }
Je souhaiterais donc avoir une classe mère de ce genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public static class GenericEnum<T extends Enum<T>> { private String name; private GenericEnum(String name){ this.name = name; } public String getName(){ return name; } }
Mais le problème est que je ne peux pas créer une enum en faisant par exemple :
Code:

1 2 3 4 public enum TestEnum extends GenericEnum<TestEnum>{ TEST("test 1"), TEST2("test2"); }
Alors comment faire pour définir un set d'enum qui ont un ensemble de méthodes communes sans redéfinir ces méthodes à chaque fois pour chaque enum???

Merci pour vos conseils!

22/03/2010, 14h00
adiGuba

Salut,

Il est impossible d'utiliser l'héritage avec les enums, car cela casserait plusieurs principes des enums et apporterait des ambiguités.

Tu peux seulement implémenter une interface commune...

a++

Peut-être quelque comme ça :

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
44
45
46
47
48
49
50
51
52
53
54
55
56
public class EnumTest {
 
  public static enum TestEnum1 {
    TEST1(new EnumWrapper<TestEnum1>("test1")), TEST2(
        new EnumWrapper<TestEnum1>("test2"));
 
    private EnumWrapper<TestEnum1> wrapper;
 
    private TestEnum1(EnumWrapper<TestEnum1> wrapper) {
      this.wrapper = wrapper;
      wrapper.setWrappee(this);
    }
 
    public EnumWrapper<TestEnum1> getWrapper() {
      return wrapper;
    }
  }
 
  public static enum TestEnum3 {
    TEST3(new EnumWrapper<TestEnum3>("test3")), TEST4(
        new EnumWrapper<TestEnum3>("test4"));
 
    private EnumWrapper<TestEnum3> wrapper;
 
    private TestEnum3(EnumWrapper<TestEnum3> wrapper) {
      this.wrapper = wrapper;
      wrapper.setWrappee(this);
    }
 
    public EnumWrapper<TestEnum3> getWrapper() {
      return wrapper;
    }
  }
 
  public static class EnumWrapper<E extends Enum<E>> {
 
    private String name;
    private E wrappee;
 
    public EnumWrapper(String name) {
      this.name = name;
    }
 
    public String getName() {
      return name;
    }
 
    void setWrappee(E wrappee) {
      this.wrappee = wrappee;
    }
 
    public E getWrappee() {
      return wrappee;
    }
  }
}

23/03/2010, 10h03
remip

Herve91,

Merci pour ta solution. Par contre elle est assez lourde en écriture de code!
Malheureusement j'ai bien l'impression que je ne vais pas trop avoir le choix. Au pire je crois que je ne vais pas passer par les enum mais par des final int.

Rémi
23/03/2010, 10h26
adiGuba

Citation:

Envoyé par remip

Au pire je crois que je ne vais pas passer par les enum mais par des final int.

Tu passes d'une extrême à l'autre là !

Au fait à quoi te sert ce nom ?

a++
23/03/2010, 10h50
tchize_

Citation:

Envoyé par adiGuba

Tu passes d'une extrême à l'autre là !

+1 tu viens en cherchant comment ne pas devoir réécrire plusieurs fois ton code getName(), et t'en arrive comme solution à prendre des int.... qui n'ont aucune méthode ni aucune rigueur. Si c'est pour en arriver là, retire simplement ta méthode "getName" de ton enum et le problème est réglé sans perdre l'avantage des enums.

PS: si tu veux juste déterminer le nom d'un enum, t'as d'autre possibilité, comme par exemple la méthode toString ;)
L'héritage des enum ne sert a rien, si on permettait l'héritage, alors l'ensemble des valeurs possible d'un enum ne serait plus fini, et donc on perdrait justement le but de l'enum. On perdrait aussi sont aspet typesafe, puisque un enum pourrait se substituer à un autre 8O
23/03/2010, 18h15
remip

Merci pour vos messages!

Alors le getName va me servir à afficher des infos à l'utilisateur. En effet, mon but est de faire un tableau avec dans chaque colonne une liste de valeurs à choisir (mes enum, c'est grâce au getName que l'utilisateur aura une info compréhensible sur les différents choix), et d'avoir un comportement dynamique, le choix effectué dans une des colonnes détermine les valeurs possibles que l'utilisateur peut choisir dans les autres colonnes!

a+
23/03/2010, 18h46
tchize_

tu peux te passer du getName ;)

enum embarque déjà une série d'informations. Ce que je te suggère

1) un fichier properties, avec des entrée du style mon.package.MonEnum.EnumXy, comme ça en plus t'es déjà ready pour la traduction :p

2) tu rempli ta liste avec des Enum

3) tu met un listCellRenderer qui va utiliser le properties d'un coté (liste des entrée dans la langue de l'utilisateur) et de l'autre coté va utiliser maValeurEnum.name(), présent dans tout enum, et qui retourne le nom déclaré de cet enum (suffisant dans ton cas pour indexer le properties)

Avantage:
1) un seul listCellRenderer compatible avec tous tes enum
2) support multingual
3) pas de "logique" d'affichage dans l'enum