Convertir java.lang.de réfléchir.Type de Classe<T> clazz

Comment puis-je convertir java.lang.reflect.Type à Class<T> clazz?

Si j'en ai une méthode comme la suivante, ce qui est un argument de Class<T>:

public void oneMethod(Class<T> clazz) {     
    //Impl
}

Puis une autre méthode qui a un argument de java.lang.reflect.Type et il appelle oneMethod(Class<T> clazz) et pour cela j'ai besoin de convertir java.lang.reflect.Type type à Class<T>:

public void someMehtod(java.lang.reflect.Type type) {
   //I want to pass type arg to other method converted in Class<T>
   otherMethod(¿How to convert java.lang.reflect.Type to Class<T>?);
}

Est-il possible?

OriginalL'auteur Pau | 2016-08-04

generics java

11

Vous devez vous assurer que type est une instance de Class, puis le jeter.
```
if (type instanceof Class) {
  @SuppressWarnings("unchecked")
  Class<?> clazz = (Class<?>) type;
  otherMethod(clazz);
}
```
Bien sûr, vous devez également gérer le cas de ne pas être un Class.

OriginalL'auteur Andy Turner
0

Il serait bizarre qu'un Type serait rien d'autre qu'un Class... Javadoc pour Type dit

Tous Connu La Mise En Œuvre De Classes:
Classe

Donc, sauf si vous avez des bibliothèques qui utilisent non Class Types, vous pouvez tout simplement jeté - mais vous devez être prêt pour une éventuelle ClassCastException.
Attention: Java utiliser sans papiers Type de mise en œuvre de représenter les génériques, voir ci-dessous.

Vous pouvez explicitement les traiter ou pas parce que c'est un décoché exception:

Manière explicite:
```
try {
    Class<?> clazz = (Class<?>) type;
}
catch (ClassCastException ex) {
    //process exception
}
```
Manière implicite:
```
Class<?> clazz = (Class<?>) type;
```
mais la méthode actuelle pourrait jeter...

ÉDITION par @Andy Turner commentaire:

Attention: Type type = new ArrayList<String>().getClass().getGenericSuperclass(); rendements quelque chose qui est un Type, mais pas une Classe. Celui-ci est un ParameterizedType, de sorte que vous pouvez utiliser getRawType() méthode pour trouver la classe réelle, mais d'autres peuvent exister.

par exemple, Type type = new ArrayList<String>().getClass().getGenericSuperclass(); rendements quelque chose qui est un Type mais pas un Class. Ideone démo.
vous avez raison, c'est un sans-papiers de la classe... On doit deviner qu'elle met en œuvre ParameterizedType et ensuite utiliser getRawType() pour trouver une vraie Classe.
C'est le point. Type peut être une instance de Class, ou il peut être une instance de ParameterizedType, TypeVariable, WildcardType, ou GenericArrayType. Le dernier 4 sont des interfaces; la mise en œuvre de la classe n'est pas pertinent.
N'oubliez pas: All Known Subinterfaces: GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType Aussi n'oubliez pas que vous pouvez anonymement implémenter une interface de n'importe où -- de sorte qu'il peut en fait être beaucoup de classes qui implémentent ces interfaces. Dans la pratique, d'autres implémentations de Type sont obtenus en appelant par exemple field.getGenericType().

OriginalL'auteur Serge Ballesta

Andy Turner réponse est correcte, mais si vous avez besoin de récupérer une classe à partir d'un paramètre de type, c'est un exemple complet:

private static class MyClass extends ArrayList<Integer> {
}

public static void main(String[] args) {

    ParameterizedType arrayListWithParamType
            = (ParameterizedType) MyClass.class.getGenericSuperclass();

    Type integerType = arrayListWithParamType.getActualTypeArguments()[0];

    Class<?> integerClass = (Class<?>) integerType;

    System.out.println(integerClass == Integer.class);
}

OriginalL'auteur xonya

0

Si vous êtes prêt à utiliser une bibliothèque, vous pouvez utiliser com.google.guava:guava:12+:
```
Class<?> clazz = com.google.common.reflect.TypeToken.of(type).getRawType();
```
Sinon vous pouvez aussi utiliser com.fasterxml.jackson.core:jackson-databind:2.8.x:
```
Class<?> clazz = com.fasterxml.jackson.databind.type.TypeFactory.rawClass(type);
```
Cela gère tous les cas correctement et vous obtiendrez le type effacé de la classe de votre type.

OriginalL'auteur Daniel Beer

-2

Vouliez-vous dire cela?

public <T extends Type> void oneMethod(T clazz) {

}

public void someMethod(Type type) {
    oneMethod(type);
}

Vous êtes juste déplacer le problème à l'intérieur de la méthode

OriginalL'auteur Claudio Zesiger

Vous devez vous connecter pour publier un commentaire.