唯一的方法是将类存储在示例变量中，并要求它作为构造函数的参数：

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

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

如果你对反射方式感兴趣，我在这篇伟大的文章中找到了部分解决方案：http://www.artima.com/weblogs/viewpost.jsp?thread=208860
简而言之，您可以使用java.lang.Class.getGenericSuperclass()和java.lang.reflect.ParameterizedType.getActualTypeArguments()方法，但是您必须子类化某个父超类。
下面的代码段适用于一个直接扩展超类AbstractUserType的类。请参阅参考文章以获得更通用的解决方案。

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());
    }

}

没有"干净"的方法可以从类中获取泛型类型参数，相反，一种常见的模式是将泛型类型的Class传递给构造函数，并将其作为内部属性，就像在java.util.EnumMap实现中所做的那样。
http://docs.oracle.com/javase/1.5.0/docs/api/java/util/EnumMap.htmlhttp://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.
    }
}

不可能。因为type erasure（类型参数被编译为Object +类型转换），所以这是不可能的。如果你 * 真的 * 需要在运行时知道/强制执行类型，你可以存储一个对Class对象的引用。

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));
   }
}

用途：

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

有一种方法可以获取type参数的运行时类型，方法是使用Guava的TypeToken捕获它，这种解决方案的缺点是每次需要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());
    }
}

这个解决方案的关键在上面代码中使用的TypeToken的构造函数的JavaDoc中描述：
客户端创建一个空的匿名子类。这样做会将类型参数嵌入到匿名类的类型层次结构中，这样我们就可以在运行时重新构造它，尽管它被擦除了。

如果你能这样定义

public class ContainerTest<T>
{

    public void doSomething(T clazz)
    {

    }
}

那就有可能