Erreur de cast sur les generics!

Version imprimable

28/09/2007, 09h13
Razgriz

Erreur de cast sur les generics!
Salut à tous,

voici mon problème, j'ai un interface Operator simple :
Code:

1 2 3 4 5 6 public interface Operator<E> { public E apply(E ... args); public String toString(); }
Dans mon application, je fais appel à un moment à eval (sur un Double dans un Operator<Double>). Jusque-là pas de problème.
Mais le resultat retourné n'est pas de type E mais de type Object.

Alors facile, je fais E result = (E)monoperator.apply(2.0);

Mais là, gros problème :

Code:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Double;

Grrrr. Je me doutais que ça allait planter avant de le faire, mais bon, je dois faire qqch come ça si je veux que mon appli reste abstraite. Comment puis-je faire pour éviter ce problème?

Merci d'avance pour vos réponses.
28/09/2007, 09h57
adiGuba

Salut,

Citation:

Envoyé par Razgriz

Dans mon application, je fais appel à un moment à eval

C'est quoi eval ?

Citation:

Envoyé par Razgriz

Mais le resultat retourné n'est pas de type E mais de type Object.

Le problème concerne plutôt des tableaux (à cause du [L devant le nom de classe). Peut-être que c'est lié au paramètre variable (qui crée en fait un tableau).

Citation:

Envoyé par Razgriz

Alors facile, je fais E result = (E)monoperator.apply(2.0);

Les Generics sont justement là pour éviter les cast !

Citation:

Envoyé par Razgriz

Mais là, gros problème :

Code:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Double;

Il faudrait le stacktrace complet et le code correspondant (avec la relation au numéro de ligne). L'exception survient surement dans la méthode et non pas à son retour...

a++

pardon, le eval, c'est la même chose que le apply.

Le truc c'est ça pour mon application : j'ai une liste chaînée (LinkedList<E>) contenant des eléments (ici des doubles) et des opérateurs (+, -, *, /, ...), la liste contenant un calcul en notation suffixée (par exemple 2 3 + 5 / correspond au calcul (2 + 3 ) / 5).

La question est d'évaluer cette liste. Bien évidement, comme vous l'avez compris, dans la définition de l'évaluation j'utilise les types générics, nécessitant un cast.

Voici le code pour l'évaluation, mais vous allez pas vous y retrouver à mon avis, c'est assez barbare :

execution représete la liste chaînée en notation suffixée. L'évaluation sur args représente une évaluation sur les variables définies dans mon expression de base. Sauf si ça vous interesse, ne vous préoccupez pas de l'algorithmique, je corrigerai ça seul si problème il y a. L'exception est lancée sur la ligne précédée de -->.

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
 
public E eval(E ... args)
    {
        if(args.length != variables.length)
            throw new IllegalArgumentException("The expression must be " +
                    "evaluated on " + variables.length + " arguments, not " +
                    "on " + args.length + " arguments");
        if(execution.size() == 0)
            throw new MalformedExpressionException("Unevaluable expression");
        else
        {
            E result = null;
            String first = execution.get(0);
            int indexvar = this.isVariable(first);
            if(indexvar != -1) //first est une variable
                result = args[indexvar];//on remplace la variable par sa valeur
            else //first est une constante
            {
                result = this.getConstantValue(first);
                LinkedList<E> stack = new LinkedList<E>();
                stack.add(result);
                Iterator<String> iterator = execution.iterator();
                while(iterator.hasNext())
                {
                    String current = iterator.next();
                    indexvar = this.isVariable(current);
                    if(indexvar != -1) //variable
                        stack.add(args[indexvar]);
                    else if(this.isConstant(current)) //constante
                        stack.add(this.getConstantValue(current));
                    else //operateur
                    {
                        int opindex = this.isOperator(current); // != -1
                        ArrayList<E> elemts = new ArrayList<E>();
                        while(stack.size() != 0)
                        {
                            elemts.add(stack.getFirst());
                            stack.removeFirst();
                        }
                        ----------->stack.add((E)(operators[opindex].apply(elemts.toArray())));
                    }
                }
                result = stack.getFirst();
            }
 
            return result;
        }
    }

Merci d'avance pour vos réponses, n'hésitez pas à poser des questions.

29/09/2007, 12h12
Razgriz
En fait c'est simple. Le problème se résume à ceci :

Soit une méthode m :
Code:

1 2 3 4 5 public E m( ... ) { ... }
Si j'ai un code nécéssitant l'appel de m (E foo = m( ...); ) je vais être obligé de caster l'appel de la méthode en E, car si je ne le fais pas il me dit que les types sont incompatibles, qu'il trouve Object et qu'il a besoin de E.

Le problème étant plus simple comme ça, quelqu'un a une idée de comment le résoudre?

Merci d'avance.
29/09/2007, 14h23
gifffftane
Ce problème se résoud par la cohérence entre les déclarations des types utilisés.

Dans ta méthode E m( ... ), (ou E est un type générique, je suppose), si l'objet supposé être du type E vient de n'importe quoi, tu n'éviteras pas, à un moment ou à un autre, un warning. C'est fait exprès. Si tu es sûr de toi, mets simplement un suppressWarning.

Mais si tu mènes d'un bout à l'autre la cohérence, alors il n'y aura pas de warning. Là aussi, c'est fait exprès.

Ex (de cohérence) :
Code:

1 2 3 4 5 <E> E m(Class<E> clazz) throws InstantiationException, IllegalAccessException { return clazz.newInstance(); }
02/10/2007, 16h56
Razgriz
bon, je fais simple :

j'ai un interface comme ceci :
Code:

1 2 3 4 5 public interface Operator<E> { public E applyOperator(E ... args); }
et j'implémente par exemple la classe Plus (implements Operator<Double>) qui va additionner tous les arguments.

Mais le problème c'est que le compilateur me dit lors d'un appel à applyOperator que la méthode renvoie un Object, pas un Double...

Ou est l'astuce?
02/10/2007, 17h00
adiGuba

Citation:

Envoyé par Razgriz

Ou est l'astuce?

Ce n'est pas évident et cela peut dépendre de plein de chose...

:arrow: Essayes de nous donner un bout de code minimum qui reproduit le problème...

a++
02/10/2007, 18h17
jhaythem

Citation:

Envoyé par Razgriz

et j'implémente par exemple la classe Plus (implements Operator<Double>) qui va additionner tous les arguments.

Mais le problème c'est que le compilateur me dit lors d'un appel à applyOperator que la méthode renvoie un Object, pas un Double...

Ou est l'astuce?

Ta class Plus ne devrait pas etre plustot comme ca? Plus implements Operator<E>?
Je crois que tu as un probleme d organisation de tes Generics c est tout.
Passe nous le code de ta classe qui implement Operator.
02/10/2007, 18h33
Razgriz

Non j'ai trouvé, tout vient d'une mauvaise utilisation des générics de ma part. J'ai corrigé en remplaçant avec des listes (ça fonctionne mieux dans mon cas en plus), maintenant tout va bien.

Nb : le problème venait du fait que lorsqu'on a un E[], c'est en réalité un Object[]... On peut utiliser dans le language des E[] mais pas en créer explicitement (E[] foo = new E[10](); ), il semblerait qu'en utiliser pose parfois certains problèmes.

Toujours est-il que mon problème est résolu, merci pour vos réponses.