Override - Type dans la signature

Version imprimable

Bonjour,

J ai une question un peu d ordre general que je me posais a propos de l overrriden de fonctions, si j ai:
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 abstract public class A {...} public class A1 extends A {...} public class A2 extends A {...} abstract public class B { ... abstract public <T extends A> void function(T t); ... } public class B1 extends B { ... @Override public <T extends A1> void function(T t); ... } public class B2 extends B { ... @Override public <T extends A2> void function(T t); ... }
pourquoi cela ne marche-t-il pas? Je sais que les fonctions doivent avoir la meme signature, et je ne comprend pas pourquoi ce n est pas le cas ici.

Sinon, comment fait-on pour obtenir un resultat similaire?

Merci

14/10/2008, 16h43
adiGuba
Salut,

Citation:

Envoyé par Malawi

Je sais que les fonctions doivent avoir la meme signature, et je ne comprend pas pourquoi ce n est pas le cas ici.

Si le type des paramètres restent T, sont "rawtype" change puisqu'il passe de A à A1 puis A2.

En clair ce n'est plus de la redéfinition mais de la surcharge (overload). C'est comme si tu avais les trois méthodes suivantes :
Code:

1 2 3 4 5 public abstract void function(A t); public abstract void function(A1 t); public abstract void function(A2 t);
a++
14/10/2008, 16h53
Malawi

Merci pour ta reponse rapide,

Je comprend bien, mais je ne trouve pas ca logique. A1 et A2 sont des extends de A, et sont donc aussi de type A.

Si je fais 3 fonctions comme tu le dis dans la classe abstraite B, n y a t-il pas un probleme d appel apres: l appel a la fonction function(A1 t) doit elle aller chercher function(A t) ou function(A1 t)? Il n y a pas une confusion possible ici?

De plus, si tu veux ajouter une troisieme classe A3 extends A plus tard, comment faire pour l ajouter sans reecrire la classe abstraite B?

N y a t -il pas une solution pour implementer le type de chose que je cherche a faire?

J ai trouve une solution:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
abstract public class A {...}
public class A1 extends A {...}
public class A2 extends A {...}
 
abstract public class B<T extends A> {
   ...
   abstract public void function(T t);
   ...
}
 
public class B1 extends B<A1> {
   ...
   @Override
   public void function(A1 t);
   ...
}
 
public class B2 extends B<A2> {
   ...
   @Override
   public void function(A2 t);
   ...
}

C est un peu barbare, mais ca marche bien...

Lorsque tu hérites tu dois respecter la totalité du contrat du parent.

Si ton code compilait sans erreurs que donnerait le code suivant :
Code:

1 2 3 B b = new B2(); b.function(new A1()); // On appelle function(A)
En effet ici on appelle function(A) qui est défini dans B et qui attend un paramètre de type A. Donc tout est correct mais on appelle une méthode qui n'existe pas puisque B2 ne déclare que function(A2)...

En fait ton utilisation des Generics n'apporte strictement rien dans ce cas précis sur une seule et unique méthode...
Bref tu pourrais remplacer ceci :

Code:

abstract public <T extends A> void function(T t);

Par cela :

Code:

abstract public void function(A t);

:arrow: La solution dans ton cas serait de passer par une surcharge :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 abstract class B { abstract public void function(A a); } class B1 extends B { @Override public void function(A a) { // On renvoi l'appel vers l'autre méthode // (en générant éventuellement une ClassCastException) this.function( (A1) a ); } // Surcharge : public void function(A1 a) { // ... } }
Une autre solution serait d'utiliser les Generics dans la déclaration de classe, en les spécialisant dans les sous-classes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 abstract class B<T extends A> { abstract public void function(T t); } class B1<T extends A1> extends B<T> { @Override public void function(T t) { } } class B2<T extends A1> extends B<T> { @Override public void function(T t) { } }
:arrow: Les sous-classes redéfinissent le type de base et modifie donc le type du paramètre.

En fait si on utilise la reflection on peut voir que c'est le compilateur qui s'occupe de générer la surcharge équivalente au code précédent :
Code:

1 2 3 for (Method method : B1.class.getDeclaredMethods()) { System.out.println(method + " " + method.isBridge()); }
Ceci en rajoutant une méthode dite "bridge" qui renvoi l'appel vers la nouvelle version (avec un cast bien sûr).

a++

[edit] Grillé !
En fait ta solution est similaire puisqu'on a 3 possibilités lorsqu'on hérite d'une classe Generics :

Soit on réutilise le type Generics tel quel :

Code:

class MaClasse<T> extends MonAutreClasse<T>

Soit on spécialise un peu plus le type Generics (dans ce cas cela doit rester cohérent avec la définition du type Generics dans la classe parente) :

Code:

class MaClasse<T extends MonType> extends MonAutreClasse<T>

Soit on "perd" les Generics et on les utilise en dur :

Code:

class MaClasse extends MonAutreClasse<MonType>

14/10/2008, 17h23
Malawi

Citation:

En effet ici on appelle function(A) qui est défini dans B et qui attend un paramètre de type A. Donc tout est correct mais on appelle une méthode qui n'existe pas puisque B2 ne déclare que function(A2)...

Bien sur ca fait une erreur, mais ca c est au developpeur de s en soucier...

La solution de surcharge que tu proposes est la solution que j avais adoptee en 1er, mais je voulais eviter de passer par la pour laisser le code le plus clair possible.

J ai donc utilise la 2nde methode que tu proposes (comme je l ai dit dans un post plus haut).

J ai donc la reponse a ma question: pas de solution simple et clair...

Merci :king:
14/10/2008, 17h26
adiGuba

Citation:

Envoyé par Malawi

Bien sur ca fait une erreur, mais ca c est au developpeur de s en soucier...

Disons que les spécifications du langage impliquent qu'il n'est pas possible d'appeler une méthode qui n'existe pas...

Donc tu dois passer par de la surcharge (et éventuellement tu peux utiliser @Deprecated sur l'ancienne version de la méthode ;))

a++