Java的泛型机制在编译阶段会进行类型检查，之后会将泛型类型信息擦除，替换为对应的上界类型或者Object类型，这就是泛型类型擦除。这个特性导致在运行时无法直接获取到泛型参数的具体类型，当需要匹配泛型方法参数时，就需要额外的方式获取对应的Class实例。
泛型类型擦除的基本表现
先看一个简单的泛型类示例，观察类型擦除后的效果：
// 定义泛型类
class GenericContainer<T> {
private T data;
public void setData(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
// 测试类
public class TypeErasureTest {
public static void main(String[] args) {
GenericContainer<String> stringContainer = new GenericContainer<>();
GenericContainer<Integer> integerContainer = new GenericContainer<>();
// 运行时两个实例的Class对象是相同的
System.out.println(stringContainer.getClass() == integerContainer.getClass()); // 输出true
}
}
上面的代码中，两个不同泛型参数的GenericContainer实例，运行时获取的Class对象是同一个，说明泛型参数T的类型信息在运行时已经不存在了。
为什么无法直接获取泛型Class实例
因为类型擦除的存在，泛型参数在编译后会被替换为上界类型，如果没有指定上界则替换为Object。比如GenericContainer<T>擦除后T变成Object，GenericContainer<T extends Number>擦除后T变成Number。运行时JVM中不存在泛型参数的具体类型信息，所以不能直接通过T.class的方式获取对应的Class实例，这种写法在编译阶段就会报错。
获取泛型Class实例的常用方法
方法一：通过方法参数显式传递Class对象
这是最常用的方式，在调用泛型方法时，把对应的Class对象作为参数传入，方法内部就可以直接使用这个Class实例来匹配参数类型。
public class GenericMethodUtil {
// 泛型方法，需要匹配泛型参数类型
public static <T> T parseData(String data, Class<T> clazz) {
// 这里可以根据clazz的类型做不同的处理逻辑
if (clazz == String.class) {
return (T) data;
} else if (clazz == Integer.class) {
return (T) Integer.valueOf(data);
}
return null;
}
public static void main(String[] args) {
// 调用时传入具体的Class实例
String strResult = parseData("hello", String.class);
Integer intResult = parseData("123", Integer.class);
System.out.println(strResult); // 输出hello
System.out.println(intResult); // 输出123
}
}
这种方式简单直接，缺点是需要调用方主动传入Class对象，不够简洁。
方法二：通过匿名内部类获取泛型超类的类型参数
Java的泛型信息在类、接口的继承关系中，如果子类指定了父类的具体泛型参数，那么这个泛型参数信息会被保留在子类的Class信息中，可以通过反射获取。
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
// 泛型基类
abstract class BaseDao<T> {
private Class<T> entityClass;
public BaseDao() {
// 获取当前类的直接超类的类型
Type superClass = getClass().getGenericSuperclass();
// 判断是否为参数化类型
if (superClass instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) superClass;
// 获取泛型参数数组，这里取第一个泛型参数
Type[] typeArgs = parameterizedType.getActualTypeArguments();
if (typeArgs.length > 0 && typeArgs[0] instanceof Class) {
entityClass = (Class<T>) typeArgs[0];
}
}
}
public Class<T> getEntityClass() {
return entityClass;
}
}
// 具体的Dao实现类，指定泛型参数为String
class StringDao extends BaseDao<String> {
}
public class SubClassTest {
public static void main(String[] args) {
StringDao stringDao = new StringDao();
System.out.println(stringDao.getEntityClass()); // 输出class java.lang.String
}
}
这种方式的原理是，匿名内部类或者普通子类在继承泛型父类时，指定了具体的泛型参数，这些参数会被记录在Class的Signature属性中，运行时可以通过反射读取。但是这种方式要求必须有一个具体的子类继承泛型类，不能直接用于普通泛型方法。
方法三：结合TypeReference类封装获取逻辑
这种方式是方法二的封装版本，在很多框架中都有使用，比如Jackson的TypeReference，通过创建一个匿名内部类继承TypeReference，来获取泛型类型信息。
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
// 类型引用封装类
abstract class TypeReference<T> {
private final Type type;
protected TypeReference() {
Type superClass = getClass().getGenericSuperclass();
if (superClass instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) superClass;
type = parameterizedType.getActualTypeArguments()[0];
} else {
throw new RuntimeException("无法获取泛型类型信息");
}
}
public Type getType() {
return type;
}
public Class<T> getRawClass() {
if (type instanceof Class) {
return (Class<T>) type;
} else if (type instanceof ParameterizedType) {
// 如果是参数化类型，获取原始类型
return (Class<T>) ((ParameterizedType) type).getRawType();
}
return null;
}
}
public class TypeReferenceTest {
public static void main(String[] args) {
// 创建匿名内部类获取泛型类型
TypeReference<String> stringTypeRef = new TypeReference<String>() {};
System.out.println(stringTypeRef.getRawClass()); // 输出class java.lang.String
TypeReference<List<Integer>> listTypeRef = new TypeReference<List<Integer>>() {};
System.out.println(listTypeRef.getType()); // 输出java.util.List<java.lang.Integer>
}
}
这种方式可以用于需要获取复杂泛型类型（比如List<Integer>）的场景，比直接传递Class对象更灵活。
匹配泛型方法参数的完整示例
结合上面的方法一，实现一个通用的数据转换方法，根据传入的Class实例匹配泛型参数类型，完成数据转换：
import java.util.HashMap;
import java.util.Map;
public class GenericParamMatcher {
// 泛型转换方法，根据clazz匹配参数类型
public static <T> T convertValue(Object source, Class<T> clazz) {
if (source == null) {
return null;
}
// 匹配目标类型
if (clazz.isInstance(source)) {
return clazz.cast(source);
}
// 处理常见类型转换
if (clazz == String.class) {
return (T) source.toString();
} else if (clazz == Integer.class || clazz == int.class) {
if (source instanceof Number) {
return (T) Integer.valueOf(((Number) source).intValue());
} else if (source instanceof String) {
return (T) Integer.valueOf((String) source);
}
} else if (clazz == Long.class || clazz == long.class) {
if (source instanceof Number) {
return (T) Long.valueOf(((Number) source).longValue());
} else if (source instanceof String) {
return (T) Long.valueOf((String) source);
}
}
throw new IllegalArgumentException("不支持从" + source.getClass() + "到" + clazz + "的转换");
}
public static void main(String[] args) {
// 测试不同类型匹配
Integer num = convertValue("123", Integer.class);
String str = convertValue(456, String.class);
Long longNum = convertValue(789, Long.class);
System.out.println(num); // 输出123
System.out.println(str); // 输出456
System.out.println(longNum); // 输出789
}
}
在实际开发中，可以根据场景选择合适的方式获取Class实例，从而正确匹配泛型方法的参数，解决类型擦除带来的问题。