这是受到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();
    }
}

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

为了完成这里的一些答案，我必须得到MyGenericClass的paramtrizedtype，不管层次结构有多高，在递归的帮助下:

private Class<T> getGenericTypeClass() {
        return (Class<T>) (getParametrizedType(getClass())).getActualTypeArguments()[0];
}

private static ParameterizedType getParametrizedType(Class clazz){
    if(clazz.getSuperclass().equals(MyGenericClass.class)){ // check that we are at the top of the hierarchy
        return (ParameterizedType) clazz.getGenericSuperclass();
    } else {
        return getParametrizedType(clazz.getSuperclass());
    }
}

如果你有这样一个类:

public class GenericClass<T> {
    private T data;
}

T变量，那么你可以打印T名称:

System.out.println(data.getClass().getSimpleName()); // "String", "Integer", etc.

Java泛型大多是在编译时，这意味着类型信息在运行时丢失。

class GenericCls<T>
{
    T t;
}

会被编译成什么样子

class GenericCls
{
   Object o;
}

要在运行时获得类型信息，必须将其作为ctor的参数添加。

class GenericCls<T>
{
     private Class<T> type;
     public GenericCls(Class<T> cls)
     {
        type= cls;
     }
     Class<T> getType(){return type;}
}

例子:

GenericCls<?> instance = new GenericCls<String>(String.class);
assert instance.getType() == String.class;

我做了相同的@Moesio上面，但在Kotlin可以这样做:

class A<T : SomeClass>() {

    var someClassType : T

    init(){
    this.someClassType = (javaClass.genericSuperclass as ParameterizedType).actualTypeArguments[0] as Class<T>
    }

}

我发现这是一个简单易懂且容易解释的解决方案

public class GenericClass<T> {

    private Class classForT(T...t) {
        return t.getClass().getComponentType();
    }

    public static void main(String[] args) {
        GenericClass<String> g = new GenericClass<String>();

        System.out.println(g.classForT());
        System.out.println(String.class);
    }
}