Discussion :

[Razgriz]

Salut à tous,

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

Code :

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

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 :

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

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.

[adiGuba]

Salut,

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

C'est quoi eval ?

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

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

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

Mais là, gros problème :

Code :

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

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

[Razgriz]

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 :

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

[Razgriz]

En fait c'est simple. Le problème se résume à ceci :

Soit une méthode m :

Code :

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

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.

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

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

1
2
3
4
5
 
	<E> E m(Class<E> clazz) throws InstantiationException, IllegalAccessException
	{
		return clazz.newInstance();
	}

[Razgriz]

bon, je fais simple :

j'ai un interface comme ceci :

Code :

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

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?

[adiGuba]

Ou est l'astuce?

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

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

a++

[jhaythem]

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.

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