public static final Class<?> getGenericArgument(final Class<?> clazz)
{
    return (Class<?>) ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments()[0];
}

当然，你可以。

出于向后兼容性的考虑，Java在运行时不使用这些信息。但是信息实际上是以元数据的形式呈现的，并且可以通过反射访问(但是它仍然不用于类型检查)。

来自官方API:

http://download.oracle.com/javase/6/docs/api/java/lang/reflect/ParameterizedType.html#getActualTypeArguments%28%29

但是，对于您的场景，我不会使用反射。我个人更倾向于将其用于框架代码。在你的例子中，我只是将类型作为构造函数参数添加。

我见过类似的东西

private Class<T> persistentClass;

public Constructor() {
    this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
                            .getGenericSuperclass()).getActualTypeArguments()[0];
 }

GenericDataAccessObjects实例

一个简单的解决方案，这种出租车如下

public class GenericDemo<T>{
    private T type;

    GenericDemo(T t)
    {
        this.type = t;
    }

    public String getType()
    {
        return this.type.getClass().getName();
    }

    public static void main(String[] args)
    {
        GenericDemo<Integer> obj = new  GenericDemo<Integer>(5);
        System.out.println("Type: "+ obj.getType());
    }
}

这里有一个方法，我用过一两次:

public abstract class GenericClass<T>{
    public abstract Class<T> getMyType();
}

随着

public class SpecificClass extends GenericClass<String>{

    @Override
    public Class<String> getMyType(){
        return String.class;
    }
}

这是受到Pablo和CoolMind的回答的启发。 我偶尔也会使用kayz1的答案中的技巧(在许多其他答案中也有表达)，我相信这是一种完成OP要求的体面而可靠的方法。

我选择首先将其定义为一个接口(类似于PJWeisberg)，因为我有可以从该功能中受益的现有类型，特别是异构泛型联合类型:

public interface IGenericType<T>
{
    Class<T> getGenericTypeParameterType();
}

我在一个通用匿名接口实现中的简单实现如下所示:

//Passed into the generic value generator function: toStore
//This value name is a field in the enclosing class.
//IUnionTypeValue<T> is a generic interface that extends IGenericType<T>
value = new IUnionTypeValue<T>() {
    ...
    private T storedValue = toStore;
    ...
    
    @SuppressWarnings("unchecked")
    @Override
    public Class<T> getGenericTypeParameterType()
    {
        return (Class<T>) storedValue.getClass();
    }
}

我想这也可以通过用类定义对象作为源来实现，这只是一个单独的用例。 我认为关键在于，正如许多其他答案所述，以某种方式，您需要在运行时获得类型信息，以便在运行时可用;对象本身保持其类型，但是擦除(也如其他人所说，使用适当的引用)会导致任何封闭/容器类型丢失该类型信息。