这里是工作解决方案!!

@SuppressWarnings("unchecked")
    private Class<T> getGenericTypeClass() {
        try {
            String className = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
            Class<?> clazz = Class.forName(className);
            return (Class<T>) clazz;
        } catch (Exception e) {
            throw new IllegalStateException("Class is not parametrized with generic type!!! Please use extends <> ");
        }
    } 

注: 只能作为超类使用 1. 必须使用类型化类进行扩展(子扩展泛型<整数>) 或 2. 必须创建为匿名实现(新的Generic<Integer>() {};)

正如其他人提到的，只有在特定的情况下通过反思才有可能。

如果你真的需要这个类型，这是常见的(类型安全的)变通模式:

public class GenericClass<T> {

     private final Class<T> type;

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

     public Class<T> getMyType() {
         return this.type;
     }
}

使用番石榴。

import com.google.common.reflect.TypeToken;
import java.lang.reflect.Type;

public abstract class GenericClass<T> {
  private final TypeToken<T> typeToken = new TypeToken<T>(getClass()) { };
  private final Type type = typeToken.getType(); // or getRawType() to return Class<? super T>

  public Type getType() {
    return type;
  }

  public static void main(String[] args) {
    GenericClass<String> example = new GenericClass<String>() { };
    System.out.println(example.getType()); // => class java.lang.String
  }
}

不久前，我在这里发布了一些完整的示例，包括抽象类和子类。

注意:这需要实例化GenericClass的一个子类，这样它才能正确地绑定类型参数。否则它只会返回类型为T。

当然，你可以。

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

来自官方API:

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

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

我认为还有另一种优雅的解决方案。

你要做的是(安全地)将泛型类型参数的类型从concerete类“传递”给父类。

如果您允许自己将类类型视为类上的“元数据”，则建议使用Java方法在运行时编码元数据:注释。

首先按照下面的代码定义一个自定义注释:

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EntityAnnotation {
    Class entityClass();
}

然后必须将注释添加到子类。

@EntityAnnotation(entityClass =  PassedGenericType.class)
public class Subclass<PassedGenericType> {...}

然后你可以使用下面的代码来获取基类中的类类型:

import org.springframework.core.annotation.AnnotationUtils;
.
.
.

private Class getGenericParameterType() {
    final Class aClass = this.getClass();
    EntityAnnotation ne = 
         AnnotationUtils.findAnnotation(aClass, EntityAnnotation.class);

    return ne.entityClass();
}

这种方法的一些局限性是:

在两个地方指定泛型类型(PassedGenericType)，而不是一个非dry类型。 只有当您可以修改具体的子类时，这才有可能。

使用返回类类型的抽象方法，然后在该类中使用它，无论在何处扩展泛型类，都必须实现该抽象方法以返回所需的类类型

public class AbsractService<T>{
  public abstract Class<T> getClassType ();
   .......
}

在运行时

class AnimalService extends AbstractService<Animal>{

@Override  
public Class<Animal> getClassType (){
        return Animal.class;
 }

  .....
}