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.

[kox2ee]

Bonjour,
Effectivement, pour faire en sorte que le type B soit un super-type de A,
la déclaration suivante (bien tentante) n'est pas possible :

<B super A>

peut-être avec java 8...

En attendant, si l'objectif est de créer une méthode qui utilise un generic B super type de A, il est possible de faire :

Code :

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

1
2
3
4
5
6
7
 
public class Bar<A> {
	// le type B doit être un super type de A
	public static <B, A extends B> B foo(Foo<B> foo, A dValue) {
		return foo.value != null ? foo.value : dValue;
	}
}

L'inconvénient est l'obligation d'utiliser le static (pour ne pas masquer le generic A),
et l'utilisation d'une valeur par défaut (qui permet d'interdire toute compilation si les paramètres passés ne respectent pas l'arbre d'héritage)

Le static est le plus problématique, puisqu'il force un appel où la généricité définie sur Bar (le A), n'est plus contrôlé que par le dValue (puisque pas de generic dans une méthode statique)...

Le résultat est presque satisfaisant :

Code :

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

1
2
3
4
5
 
Foo<Integer> foo = new Foo<>();
foo.value = 5;
Bar<String> b = new Bar<>();
Integer i=Bar.foo(foo, "");//ne compile pas puisque String n'est pas une super-classe de Integer

Code :

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

1
2
3
4
5
 
Foo<Integer> foo = new Foo<>();
foo.value = 5;
Bar<Number> b = new Bar<>();
Integer i=Bar.foo(foo, 0);//Compilation ok : Number super classe de Integer

Le problème est seulement que l'appel de foo ne peut-être associé à une instance particulière de BAR...

[le y@m's]

Bonjour,
Effectivement, pour faire en sorte que le type B soit un super-type de A,
la déclaration suivante (bien tentante) n'est pas possible :


peut-être avec java 8...

Tu dis peut-être avec java 8 comme ça ou c'est quelque chose de vraiment prévu (j'avoue ne pas m'être trop penché sur les nouveautés de java 8) ?

En attendant, si l'objectif est de créer une méthode qui utilise un generic B super type de A, il est possible de faire :

...

Le problème est seulement que l'appel de foo ne peut-être associé à une instance particulière de BAR...

J'avais effectivement trouvé cette façon de faire, à vrai dire cela a même été mon point de départ. D'une méthode statique j'ai voulu en faire une méthode d'instance pour un confort d'utilisation. Mais bon visiblement, comme je le craignais, ce n'est pas possible.


En tout cas merci à tous de vous y être penché dessus, je laisse le sujet non résolu, toute nouvelle réflexion y est la bienvenue

[kox2ee]

Affirmation sans fondement pour Java 8...
Je n'ai pas lu ça sur le sujet.

Je voulais simplement dire qu'il se pourrait qu'on y arrive un jour, à la possible implémentation de ce <A super B> qui a un sens conceptuel