Question sur l'utilisation d'Enum generique.

Version imprimable

Bonjour amis développeurs.

Je me pose des questions à propos de l'utilisation de types générique avec les Enum. Mon code fonctionne correctement mais il y a des warnings que je n'arrive pas a comprendre.

J'ai une classe Parameter generique qui contient les méthodes setValue et getValue paramétrées
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class Parameter<T> { //... des truc avant public void setValue(final T _value) { value = _value; } synchronized public T getValue() { return value; } //... des truc après }
J'ai créé une classe EnumParameter
Code:

1 2 3 4 5 6 7 8 9 public class EnumParameter<T extends Enum<T>> extends Parameter<T> { public EnumParameter(final Class<T> _enumType) { super(_enumType); ... } }
Je créé deux EnumParameter avec deux types d'Enum différents que j'ajoute dans une map. Comme ceci.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 { ... EnumParameter<Enum1> parameter1 = new EnumParameter<>(Enum1.class); EnumParameter<Enum2> parameter2 = new EnumParameter<>(Enum2.class); parameter1.setValue(Enum1.TRUC); parameter2.setValue(Enum2.MACHIN); parametersMap.put(parameter1ID, parameter1); parametersMap.put(parameter2ID, parameter2); ... }
Plus tard je veux récupérer par exemple la valeur de parameter1 pour l'assigner a un autre EnumParameter.
Code:

1 2 3 4 final EnumParameter<Enum1> parameter1 = (EnumParameter<Enum1>)getParameter(parameter1ID); // WARNING : Type safety: Unchecked cast from Parameter<capture#31-of ?> to EnumParameter<Enum1> final EnumParameter<Enum1> parameter3 = (EnumParameter<Enum1>)getParameter(parameter3ID); // WARNING : Type safety: Unchecked cast from Parameter<capture#31-of ?> to EnumParameter<Enum1> parameter3.setValue(parameter1 .getValue());
Mis à part le warning ça fonctionne.

J'ai essayé de résoudre le warning avec <?>
Code:

1 2 3 4 final EnumParameter<?> parameter1 = (EnumParameter<?>)getParameter(parameter1ID); // Plus de warning final EnumParameter<?> parameter3 = (EnumParameter<?>)getParameter(parameter3ID); // Plus de warning parameter3.setValue(parameter1 .getValue()); // ERREUR : The method setValue(capture#35-of ?) in the type Parameter<capture#35-of ?> is not applicable for the arguments (capture#36-of ?)
Je comprends l'erreur puisque le paramètre est de type EnumParameter<?> et j'essaie de luis passer un parametre de type Enum1.
Et donc comment éviter le Unchecked cast warning dans ce cas si c'est possible.

Merci d'éclairer ma lanterne.

15/05/2019, 12h58
Pill_S

Il faut montrer le code de getParameter aussi stp... c'est là que le problème est (elle ne peut pas retourner Object, car alors le cast est unsafe). Il faudrait passer le type en argument, ce qui permettrait de supprimer le cast explicite.

Salut Pill_S

Code:

1
2
3
4
5
6
7
 
        private Map<String,Parameter<?>> parametersMap; // La map de paramètres.
 
        public Parameter<?> getParameter(final String _key)
	{
		return parametersMap.get(_key);
	}

Tout simplement.

PS:
J'aime beaucoup ta signature :D

Bon il y aurait une solution comme ça, même si peut-être qu'on peut faire mieux avec les génériques (suis pas un cador à ce niveau...), et il reste quand même un cast unchecked mais centralisé à un seul endroit... Pour le client de l'api il n'y voit rien.

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
57
58
59
60
61
62
 
public class Demo {
    private static Map<String, Parameter<?>> parametersMap;
 
    static {
        parametersMap = new HashMap<>();
        parametersMap.put("string", new Parameter<>("string"));
        parametersMap.put("integer", new Parameter<>(Integer.valueOf(42)));
        parametersMap.put("boolean", new Parameter<>(Boolean.TRUE));
    }
 
    public static void main(String[] xxx) {
        Parameter<String> string = getParameter("string", String.class);
        System.out.println(string); // print string
 
        Parameter<Integer> integer = getParameter("integer", Integer.class);
        System.out.println(integer); // print 42
 
        Parameter<Boolean> aBoolean = getParameter("boolean", Boolean.class);
        System.out.println(aBoolean); // print true
 
        System.out.println(getParameter("integer", Boolean.class)); // Class cast exception
    }
 
    public static <T> Parameter<T> getParameter(final String _key, Class<T> clazz) {
        Parameter<?> param = parametersMap.get(_key);
        Object value = param.getValue();
 
        if (value == null) {
            return null;
        }
 
        if (clazz.isAssignableFrom(value.getClass())) {
            @SuppressWarnings("unchecked")
            Parameter<T> p = (Parameter<T>) param;
            return p;
        }
 
        throw new ClassCastException(value.getClass() + " is not a subclass of " + clazz);
    }
 
    public static class Parameter<T> {
        T value;
 
        Parameter(T value) {
            this.value = value;
        }
 
        public T getValue() {
            return value;
        }
 
        public void setValue(T value) {
            this.value = value;
        }
 
        @Override
        public String toString() {
            return "" + value;
        }
    }
}

Sinon la signature vient des trèèèèès nombreuses citations qu'on peut lire partout. Si Einstein a vraiment dit ne serait-ce que la moitié de ce qu'on lui attribue, il a parlé en 20 ans plus que ma copine en toute une vie ;)

29/05/2019, 11h31
Dia972

Bonjour Pill_S, désolé pour la réponse tardive j'ai eu d'autres trucs urgents a régler.
Merci pour la réponse. Je vais utiliser ta méthode c'est bien mieux d'avoir 1 seul warning.
Je ne sais pas si c'est possible de ne plus en avoir du tout mais je n'ai pas réussi.