Discussion :

[Dia972]

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 :

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

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

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 :

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

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 :

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

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 :

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

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.

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

[Dia972]

Salut Pill_S

Code :

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

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

[Pill_S]

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 :

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

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