Discussion :

[le y@m's]

Bonjour tout le monde,

bon le titre n'est peut être pas très parlant, voici mon problème :

Soit les classes suivantes

Code :

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

1
2
3
class Foo<T> {
  T value;
}

Code :

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

1
2
3
4
5
6
7
class Bar<A> {
 
    // le type B doit être un super type de A
    <B> B bar(Foo<B> foo) {
        return foo.value;
    }
}

Pour la méthode bar, je voudrais imposer que le type B soit un super type du type A défini pour la classe. Un peu comme si on pouvait définir <B super A> (ce qui n'est pas le cas).
Savez vous comment faire ?

Merci d'avance.

le y@m's

[wax78]

Je n'ai pas bien compris toute la question, donc j'y réponds surement pas la bonne réponse, mais pour faire <B super A> tu dois utiliser extends a la place du mot super <B extends A>.

[le y@m's]

Je n'ai pas bien compris toute la question, donc j'y réponds surement pas la bonne réponse, mais pour faire <B super A> tu dois utiliser extends a la place du mot super <B extends A>.

<B extends A> indique que le type B doit être un sous-type de A (B une classe fille de A). Moi je veux l'inverse, je veux que B soit un super-type de A (B une classe parente de A).

[wax78]

Autant pour moi j'avais bien mal compris

[le y@m's]

Une "presque solution" est d'utiliser le wildcard ? super mais le problème c'est que le type parent n'est pas "explicite" et donc ne peut être utiliser pour donner le type de retour de la méthode qui devient Object.

Code :

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

1
2
3
Object bar(Foo<? super A> foo) {
    return foo.value;
}

Mais je voudrais conserver le type B pour le type de retour de la méthode.

[thelvin]

À ma connaissance les génériques ne peuvent pas exprimer de contrainte dans les deux sens, même s'il existe des cas où ça aurait du sens.

Voilà ce que j'ai fait une fois :

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
public interface FFoo<T1, T2> {
  T1 getValue();
  void accept(T2 t2);
}
 
public class Foo<T> implements FFoo<T, T> {
  T value;
  T getValue() {
    return value;
  }
  void accept(T t) {
 
  }
}
 
public class Bar<A> {
  A value;
  <B> B bar(FFoo<B, ? super A> foo) {
    foo.accept(value);
    return foo.getValue();
  }
 
  public static void main(String[] args) {
    Bar<Integer> bar = new Bar<Integer>();
    bar.value = 1;
 
    Foo<Number> foo = new Foo<Number>();
    foo.value = 2;
    Number n = bar.bar(foo);
  }
}

Mais la seule manière que je connaisse d'imposer que FFoo<T1, T2> soit en réalité un Foo<T>, c'est une vérification au runtime.
Pas de solution idéale.