Différence entre les paramètres génériques Java

Question

Quelle est la différence entre la transmission d'un paramètre générique d'une classe générique avec et sans son paramètre générique?

Exemple:

simple classe générique:

public class Foo<T> { /*...*/ } 

classe simple qui se prolongent classe simple générique définissant le paramètre générique à un certain type non pertinent:

public class FooFoo extends Foo<Type1> { /*...*/ } 

Une autre classe générique

public class Bar<T> extends FooFoo { /*...*/ } 

Notre classe de base en tant que paramètre générique besoin de quelque chose qui étend la classe Foo

public class TestFooClass<T extends Foo<?>> { /*...*/ } 

Et la question, quelle est la déférence entre ces deux paramètres

public class BarTestOne extends TestFooClass<Bar> { /*...*/ } 

public class BarTestTwo extends TestFooClass<Bar<?>> { /*...*/ } 

Problème

Class<T> class = (Class<T>) ((Foo)getClass().getGenericSuperclass()).getActualTypeArguments()[0]; 

Dans le Le premier cas fonctionne dans le second cas.

Answer 1

Il semble que vous essayez de déterminer le type réel avec lequel le TestFooClass est paramétré?

Dans ce contexte, la différence entre l'utilisation de la classe générique avec et sans son paramètre générique est que getActualTypeArguments() [0]:

1. Dans le premier cas fournir une instance de la classe représentant le type brut
2. Dans le second cas, fournissez une instance de ParameterizedType (donc on peut obtenir ClassCastException). Si vous appelez getRawType() sur ce ParameterizedType, vous obtiendrez une classe représentant le type brut.

Ce:

BarTestOne one = new BarTestOne(); 
BarTestTwo two = new BarTestTwo(); 

Class<?> clazz1 = (Class<?>) ((ParameterizedType) one.getClass().getGenericSuperclass()).getActualTypeArguments()[0];  
Class<?> clazz2 = (Class<?>) ((ParameterizedType) ((ParameterizedType) two.getClass().getGenericSuperclass()).getActualTypeArguments()[0]).getRawType(); 

System.out.println(clazz1.equals(clazz2)); 

Cela renverra vrai. Hélas, toute réponse plus profonde dépasse mes connaissances des génériques.

Answer 2

Bar signifie Bar<Object> et Bar<?> non. Par exemple, si vous avez un List, vous pouvez y ajouter, si vous avez un List<?> vous ne pouvez pas, car le compilateur ne sait pas si votre objet est compatible avec le "type générique réel" de l'objet.

Quant au code de réflexion, je ne sais pas. Il dit getClass(), qui dépend de l'objet sur lequel vous l'appelez; dans ce cas l'objet est évidemment this ... D'où vient ce code?