如何在泛型类的方法中返回其类型参数的类型？

代码示例 #

public class HasList<T> {
    private List<T> list;

    public ? getType() {
        return // ??
    }
}

我通常认为类型由Class<?>表示，例如通过.class属性，但可能存在更优的类型表示方式来解决此问题。

期望效果 #

var hasListString = new HasList<String>();
var hasListInteger = new HasList<Integer>();
hasListString.getType() // -> 代表String类型的对象
hasListInteger.getType() // -> 代表Integer类型的对象

因为Java泛型采用类型擦除机制，运行时泛型参数信息会被默认抹除，所以无法直接从HasList<T>的普通实例中获取T的类型，必须通过额外手段保留类型信息，以下是几种实用方案：

方案1：构造时传入Class对象（最直接稳定） #

主动将类型信息传递给实例并保存，这是工业界最常用的方式：

import java.util.List;

public class HasList<T> {
    private List<T> list;
    private final Class<T> type;

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

    public Class<T> getType() {
        return type;
    }
}

使用示例：

var hasListString = new HasList<>(String.class);
var hasListInteger = new HasList<>(Integer.class);
System.out.println(hasListString.getType()); // 输出 class java.lang.String
System.out.println(hasListInteger.getType()); // 输出 class java.lang.Integer

方案2：利用匿名子类+反射获取类型 #

Java会为匿名内部类保留泛型参数信息，通过反射提取该信息：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

public class HasList<T> {
    private List<T> list;
    private final Type type;

    public HasList() {
        Type superType = getClass().getGenericSuperclass();
        if (superType instanceof ParameterizedType parameterizedType) {
            // 提取第一个泛型参数
            this.type = parameterizedType.getActualTypeArguments()[0];
        } else {
            throw new IllegalArgumentException("必须通过匿名子类或带泛型参数的子类实例化");
        }
    }

    public Type getType() {
        return type;
    }
}

注意使用方式必须创建匿名子类：

// 末尾的{}表示创建匿名子类，否则会丢失泛型信息
var hasListString = new HasList<String>() {};
var hasListInteger = new HasList<Integer>() {};
System.out.println(hasListString.getType()); // 输出 class java.lang.String
System.out.println(hasListInteger.getType()); // 输出 class java.lang.Integer

方案3：借助Guava的TypeToken（适合复杂泛型场景） #

如果项目引入Guava库，可以用TypeToken简化复杂泛型的类型获取，本质也是利用匿名子类保留信息：

import com.google.common.reflect.TypeToken;
import java.util.List;

public class HasList<T> {
    private List<T> list;
    private final TypeToken<T> typeToken;

    public HasList() {
        this.typeToken = new TypeToken<T>(getClass()) {};
    }

    // 获取原始Class类型（适合简单泛型）
    public Class<T> getType() {
        return (Class<T>) typeToken.getRawType();
    }

    // 获取完整泛型类型（适合List<String>这类复杂场景）
    public TypeToken<T> getTypeToken() {
        return typeToken;
    }
}

使用示例：

var hasListString = new HasList<String>() {};
System.out.println(hasListString.getType()); // 输出 class java.lang.String

类型表示方式选择 #

• 若仅需基础类类型（如String、Integer），Class<?>完全够用，它支持实例化、反射调用方法等绝大多数操作；
• 若需处理复杂泛型（如List<String>、Map<Integer, List<String>>），则使用Type或Guava的TypeToken，它们能保留完整的泛型结构信息。

内容的提问来源于stack exchange，提问作者user3310334