Discussion :

[remip]

Bonjour,

Voici mon problème, j'ai un liste d'enum qui ont des méthodes similaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[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++

[herve91]

Peut-être quelque comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

[adiGuba]

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++

[tchize_]

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

[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+

[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