Comment obtenir la classe de variable de type dans Java Generics

J'ai vu des questions similaires, mais ils n'ont pas beaucoup aider.

Par exemple j'ai cette Classe Générique:

public class ContainerTest<T>
{

    public void doSomething()
    {
        //I want here to determinate the Class of the type argument (In this case String)
    }
}

et une Autre Classe qui utilise cette Classe de Conteneur

public class TestCase
{

    private ContainerTest<String> containerTest;

    public void someMethod()
    {
        containerTest.doSomething();
    }
}

Est-il possible de déterminer la Classe du type d'argument dans la méthode doSomething() sans avoir un type explicite variable/champ ou tout constructeur dans ContainerTest Classe?

Mise à jour: modification du format de ContainerTest Classe

source d'informationauteur ZeDonDino

C'est le seul moyen de stocker de la classe dans une variable d'instance et d'exiger, comme un argument du constructeur:

public class ContainerTest<T>
{
    private Class<T> tClass;
    public ContainerTest(Class<T> tClass) {
        this.tCLass = tClass;
    }

    public void doSomething()
    {
        //access tClass here
    }
}

Si vous êtes intéressé dans le réflexion façonj'ai trouvé une solution partielle dans cet excellent article: http://www.artima.com/weblogs/viewpost.jsp?thread=208860

En bref, vous pouvez utiliser java.lang.Class.getGenericSuperclass() et java.lang.reflect.ParameterizedType.getActualTypeArguments() méthodes, mais vous avez une classe de certains parents super classe.

L'extrait de code suivant fonctionne pour une classe qui directement étend la super-classe AbstractUserType. Voir l'article référencé pour plus de solution générale.

import java.lang.reflect.ParameterizedType;


public class AbstractUserType<T> {

    public Class<T> returnedClass() {
        ParameterizedType parameterizedType = (ParameterizedType) getClass()
                .getGenericSuperclass();

        @SuppressWarnings("unchecked")
        Class<T> ret = (Class<T>) parameterizedType.getActualTypeArguments()[0];

        return ret;
    }

    public static void main(String[] args) {
        AbstractUserType<String> myVar = new AbstractUserType<String>() {};

        System.err.println(myVar.returnedClass());
    }

}

5

Il n'y a pas de manière "propre" pour obtenir de l'argument de Type Générique de l'intérieur de la classe.
Au lieu de cela, un modèle commun est de passer de la Classe de Type Générique, le constructeur et le garder comme un intérieur de la propriété juste comme le fait la java.util.EnumMap mise en œuvre.

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/EnumMap.html
http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/EnumMap.java
```
public class ContainerTest<T> {

    Class<T> type;
    T t;

    public ContainerTest(Class<T> type) {
        this.type = type;
    }

    public void setT(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void doSomething() {
        //There you can use "type" property.
    }
}
```

Pas. Il n'est pas possible en raison de type d'effacement (le type des paramètres sont compilés en tant qu'Objet de type plâtre). Si vous vraiment besoin de savoir/faire respecter le type de runtime vous pouvez stocker une référence à un Class objet.

public class ContainerTest<T> {
   private final Class<T> klass;
   private final List<T> list = new ArrayList<T>();

   ContainerTest(Class<T> klass) {
     this.klass = klass;
   }

   Class<T> getElementClass() {
     return klass;
   }

   void add(T t) {
      //klass.cast forces a runtime cast operation
      list.add(klass.cast(t));
   }
}

Utilisation:

ContainerTest<String> c = new ContainerTest<>(String.class);

D'apprendre la valeur de T vous aurez besoin de le capturer dans une définition de type de sous-classement par ContainerTest:

class MyStringClass extends ContainerTest<String> {}

Vous pouvez aussi le faire avec une classe anonyme si vous le souhaitez:

ContainerTest<String> myStringClass = new ContainerTest<String>{}();

Ensuite pour régler la valeur de T, vous pouvez utiliser Adresse typetools:

Class<?> stringType = TypeResolver.resolveRawArgument(ContainerTest.class, myStringClass.getClass());
assert stringType == String.class;

Si Vous pouvez définir comme ce

public class ContainerTest<T>
{

    public void doSomething(T clazz)
    {

    }
}

Alors il est possible

Il est un moyen d'obtenir l'exécution type de le type de paramètre à l'aide de la Goyave est TypeToken de le capturer. La solution a un inconvénient est que vous devez créer un anonyme sous-classe chaque fois que vous besoin d'une instance de Container.

class Container<T> {

    TypeToken<T> tokenOfContainedType = new TypeToken<T>(getClass()) {};

    public Type getContainedType() {
        return tokenOfContainedType.getType();
    }
}

class TestCase {

    //note that containerTest is not a simple instance of Container,
    //an anonymous subclass is created
    private Container<String> containerTest = new Container<String>() {};

    @Test
    public void test() {
        Assert.assertEquals(String.class, containerTest.getContainedType());
    }
}

La clé de cette solution est décrite dans la JavaDoc de TypeToken'constructeur utilisé dans le code ci-dessus:

Clients à créer un vide anonyme sous-classe. Ce faisant intègre le paramètre de type dans la classe anonyme du type de hiérarchie, donc on peut le reconstituer à l'exécution, en dépit de l'effacement.

Vous devez vous connecter pour publier un commentaire.