Discussion :

[nicorama]

Edit : l'ensemble du post est un peu confus (j'étais vénère ). La version anglaise sur le fourm Sun est plus claire : http://forum.java.sun.com/thread.jspa?threadID=5262288

Je crée des listes de Couples<Integer, String>.
Quand j'enlève un de ces couples, j'ai une liste Enfant qui doit enlever le String correspondant grace à ces fonction :

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
 
 
class MyList<String> extends Vector<String> implements ChildList{
 
    public void fireClear() {
        clear();
    }
 
    /**
     * ici o correspond à un Couple
     * @param o
     */
    public void fireRemove(Couple<Integer, String> couple) {
        System.out.println("avant :"+this);
        remove(couple.getRightElement());
        System.out.println("après :"+this);
    }
   /* Si on veut enlever directement le String ou n'importe quoi */
    public void fireRemove(Object o) {
        remove(o);
    }
 
}

Puis je remplis mes listes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
ParentCoupleList<Integer, String> listParent=new ParentCoupleList<Integer, String>();
Couple<Integer, String>c1,c2,c3,c4,c5;
c1=new Couple<Integer, String>(1, "1");
c2=new Couple<Integer, String>(2, mySuperString);
listParent.add(c1);listParent.add(c2);
 
myList=new MyList();
myList.add(mySuperString);myList.add(myOtherSuperString);
 
listParent.registerChildList(myList);

Et en principe, quand je supprime le couple c2 de la listeParent, je lance la fonction fireRemove(c2).

Malheureusement, le debugguer me dit que c'est la fonction fireRemove(Object o) plutot que fireRemove(Couple<Integer, String> couple) qui est choisie.

Pourquoi donc ??????????????????????????????????

PS : la classe ParentCoupleList a été testée et fonctionne correctement

[nicorama]

J'ai un problème tout bête dans une classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
 public void fireRemove(Couple couple) {
        remove(couple.getRightElement());
    }
 
    public void fireRemove(Object o) {
        if (o instanceof Couple) fireRemoveCouple((Couple)o);
        else remove(o);
    }

QUand je lance la fonction fireRemove(unCouple), comme Couple extends Object, cet ##{{ de JVM lance la fonction public void fireRemove(Object o), au lieu de celle destinée au Couple.

Je suppose que la JVM a ses raisons et mon bouquin de certification ne m'en dit pas davantage.
Je contourne donc le problème ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
 
 public void fireRemoveCouple(Couple couple) {
        remove(couple.getRightElement());
    }
 
    public void fireRemove(Object o) {
        if (o instanceof Couple) fireRemoveCouple((Couple)o);
        else remove(o);
    }

Mais c'est pas beau, et si les héritages se multiplient, ce sera pire. Une idée ?

[jhaythem]

Moi aussi j ai revu mon bouquin de certif... et ca ne dit rien...
c est pas logique ce qui ce passe... je te conseil de poster ton problem sur javaranch.com ou directement sur le site de sun.
Tu toucheras une beaucoup plus large audience... si tu as besoin d aide pour formuler ta question en anglais envoie moi MP.

Fais nous partager ta reponse plus tard.

[nicorama]

Ce qui est bizarre, c'est qu'avec :

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
 
 
    public void enleve(Object objet) {
 
        assert objet != null : "Erreur objet null";
        assert !(objet instanceof Eleve);
        assert !(objet instanceof Professeur);
 
        //On ne fait rien
        if (objet instanceof MembreAdministration) {
            return;
        }
    }
 
    public void enleve(Eleve eleve) {
        assert eleve != null : "Erreur objet null";        
         this.facade.enleveListeEleves(v);       
    }
 
    public void enleve(Professeur prof) {
        assert prof != null : "Erreur objet null";
         this.enleveProfPrincipal();
 
    }

ca marche nickel. Donc je me demande si il n'y a pas une méga embrouille avec les générics. Mais même en enlevant uen bonne partie de tout ce qui touche à ces générics, je passe toujours par la fonction fireRemove(Object o) et pas fireRemove (Couple c)

Merci aux admin d'avoir recoupé mes messages - je me suis bien embourbé dans ma mouise . Je vais m'coucher !

[nicorama]

Plus bizarre encore :
Quand je fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 public void fireRemove(Couple<Integer, String> couple) {
        System.out.println("avant :"+this);
        remove(couple.getRightElement());
        System.out.println("après :"+this);
    }
 
    public void fireRemove(Object o) {
        if (o instanceof Couple) fireRemove((Couple)o);
        remove(o);
    }

Ca marche nickel alors que ca pourrait boucler à l'infini. La conversion en Couple pousse vers public void fireRemove(Couple<Integer, String> couple), ce qui me fait dire que les generics n'ont rien à voir là-dedans.

Par contre si à l'extérieur de la Class je fais :
registeredChildLists.get(i).fireRemove((Couple)couple);

Alors je passe par public void fireRemove(Object o)

Comme ca n'est pas documenté, je me dis finalement que ca marche au petit bonheur la chance - on ne peut pas leur en vouloir, mais c'est très contre-intuitif et il faut le savoir.

Ou alors j'ai fait une méga bévue de débutant . Je vais tenter la traduction pour demain.

[gifffftane]

Change de JVM, ou change de debogueur, ou efface tout et recommence.

Pour résumer, en cas de définition mutliple d'une méthode, l'appel choisi sera celui correspondant aux classes déclarées, non aux classes effectives.

Par exemple, si tu as

Code :

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

1
2
3
4
 
void toto(Object trux){ ... } /* 1 */
 
void toto[String truc){ ... } /* 2 */

L'appel toto("hello world") choisira 2.

Par contre, Object hello = "hello world" ; toto(hello); choisira 1.