Java泛型

一、泛型的核心作用

1. 类型安全（Type Safety）

   • 编译期类型检查：在编译阶段捕获类型错误，避免运行时ClassCastException
   • 示例对比：

     // 非泛型（有风险）
     List list = new ArrayList();
     list.add("text");
     Integer num = (Integer) list.get(0); // 运行时ClassCastException
     
     // 泛型（安全）
     List<String> safeList = new ArrayList<>();
     safeList.add("text");
     // safeList.add(123); // 编译错误
     String text = safeList.get(0); // 无需强制转换
     

2. 消除强制类型转换

   • 自动类型推导：编译器自动插入类型转换代码
   • 字节码验证（反编译查看）：

     // 源代码
     List<String> list = new ArrayList<>();
     String s = list.get(0);
     
     // 等效字节码
     List list = new ArrayList();
     String s = (String) list.get(0); // 编译器自动添加checkcast
     

3. 代码复用与抽象

   • 通用算法实现：如Collections.sort()可处理任意Comparable类型
   • 类型参数化容器：HashMap<K,V>可存储任意键值类型组合

4. API设计清晰化

   • 自文档化：Map<Department, List<Employee>>直接表达数据结构关系
   • 约束明确化：<T extends Comparable<T>>声明类型必须可比较

---

二、实现机制：类型擦除（Type Erasure）深度解析

1. 编译期处理流程

2. 类型擦除规则

泛型声明	擦除后类型	示例
List<T>	List	List<String> → List
List<?>	List	-
List<? extends T>	List	List<? extends Number> → List
T（无界）	Object	T get() → Object get()
T extends Number	Number	T value → Number value
T extends A & B	A（第一边界）	T → A

3. 桥接方法（Bridge Method）

解决多态与类型擦除的冲突：

interface Comparable<T> {
    int compareTo(T o);
}

class String implements Comparable<String> {
    // 编译器生成桥接方法
    public int compareTo(Object o) {
        return compareTo((String) o); // 委托给泛型方法
    }
    
    public int compareTo(String s) { ... }
}

4. 类型擦除验证实验

import java.lang.reflect.Method;
import java.util.*;

public class ErasureProof {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> ints = new ArrayList<>();
        
        // 1. 类类型相同
        System.out.println(strings.getClass() == ints.getClass()); // true
        
        // 2. 反射绕过类型检查
        try {
            Method addMethod = strings.getClass().getMethod("add", Object.class);
            addMethod.invoke(strings, 100); // 成功添加Integer到List<String>
            System.out.println("List content: " + strings.get(0)); // 输出100
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 3. 取值时抛出异常
        String s = strings.get(0); // ClassCastException: Integer->String
    }
}

---

三、泛型的优缺点分析

✅ 核心优势

1. 编译时类型安全：减少90%+的类型转换错误
2. 代码简洁性：消除冗余的类型转换代码
3. 设计抽象能力：构建类型无关的通用算法（如Collections.sort()）
4. 开发体验优化：IDE支持泛型类型自动推导和提示

⚠️ 关键局限性

1. 类型擦除的代价：

   • 运行时类型信息丢失
   • 无法创建泛型数组：new T[10] 非法
   • 不能实例化类型参数：new T() 非法

2. 继承与多态问题：

   class Box<T> {}
   // 以下非法，因为List<String>和List<Object>无继承关系
   List<Object> list = new ArrayList<String>(); 
   

3. 基本类型不支持：

   // 必须使用包装类
   List<int> invalid; // 编译错误
   List<Integer> valid; 
   

4. 异常处理限制：

   // 不能捕获泛型异常实例
   try { ... }
   catch (SomeException<Integer> e) {} // 非法
   

---

四、反射操作泛型深度实践

1. 反射获取泛型信息的原理

• 保留的泛型信息：

  • 类/接口的泛型父类（Class.getGenericSuperclass()）
  • 字段的泛型声明（Field.getGenericType()）
  • 方法的泛型返回类型（Method.getGenericReturnType()）
  • 方法参数的泛型类型（Method.getGenericParameterTypes()）

• 不可获取的信息：

  • 运行时对象的具体泛型类型
  • 局部变量的泛型类型

2. 完整反射Demo

import java.lang.reflect.*;
import java.util.*;

public class GenericReflectionLab {

    static class DataNode<T> {
        private T nodeData;
        public List<Map<String, T>> dataMap;
    }

    static class StringNode extends DataNode<String> {
        public Map<Long, List<String>> complexField;
    }

    public static void main(String[] args) throws Exception {
        // 1. 获取类继承的泛型父类参数
        Type superType = StringNode.class.getGenericSuperclass();
        printTypeInfo("父类泛型", (ParameterizedType) superType);

        // 2. 获取字段的泛型信息
        Field field = StringNode.class.getField("complexField");
        printTypeInfo("字段泛型", (ParameterizedType) field.getGenericType());

        // 3. 获取方法的泛型返回类型
        Method method = GenericReflectionLab.class.getMethod("getData", Object.class);
        printTypeInfo("方法返回类型", (ParameterizedType) method.getGenericReturnType());

        // 4. 获取方法参数的泛型信息
        Type[] paramTypes = method.getGenericParameterTypes();
        ParameterizedType paramType = (ParameterizedType) paramTypes[0];
        System.out.println("\n方法参数泛型: " + paramType);
        System.out.println("  原始类型: " + paramType.getRawType());
        System.out.println("  实际类型参数: " + paramType.getActualTypeArguments()[0]);
    }

    public static <T> Map<String, List<T>> getData(T input) {
        return null;
    }

    private static void printTypeInfo(String title, ParameterizedType type) {
        System.out.println("\n" + title + "信息:");
        System.out.println("  原始类型: " + type.getRawType());
        
        Type[] actualTypes = type.getActualTypeArguments();
        for (int i = 0; i < actualTypes.length; i++) {
            System.out.println("  类型参数" + (i+1) + ": " + actualTypes[i]);
            
            // 处理嵌套泛型
            if (actualTypes[i] instanceof ParameterizedType) {
                Type[] nestedTypes = ((ParameterizedType) actualTypes[i]).getActualTypeArguments();
                for (int j = 0; j < nestedTypes.length; j++) {
                    System.out.println("    ↳ 嵌套参数" + (j+1) + ": " + nestedTypes[j]);
                }
            }
        }
    }
}

3. 输出解析

父类泛型信息:
  原始类型: class GenericReflectionLab$DataNode
  类型参数1: class java.lang.String

字段泛型信息:
  原始类型: interface java.util.Map
  类型参数1: class java.lang.Long
  类型参数2: interface java.util.List
    ↳ 嵌套参数1: class java.lang.String

方法返回类型信息:
  原始类型: interface java.util.Map
  类型参数1: class java.lang.String
  类型参数2: interface java.util.List
    ↳ 嵌套参数1: T

方法参数泛型: T
  原始类型: class java.lang.Object
  实际类型参数: T

4. 关键反射API解析

API	返回信息说明	支持类型
Class.getGenericSuperclass()	带泛型信息的父类/接口	ParameterizedType
Field.getGenericType()	字段的声明类型（含泛型）	TypeVariable/ParameterizedType
Method.getGenericReturnType()	方法返回类型（含泛型）	TypeVariable/ParameterizedType
Method.getGenericParameterTypes()	方法参数类型（含泛型）	Type[]
ParameterizedType.getActualTypeArguments()	获取实际类型参数	Type[]

---

五、最佳实践与解决方案

1. 绕过类型擦除限制的技巧

// 实例化泛型类型（通过Class参数）
public static <T> T createInstance(Class<T> clazz) 
    throws Exception {
    return clazz.getDeclaredConstructor().newInstance();
}

// 创建泛型数组（类型安全方式）
public static <T> T[] createArray(Class<T> clazz, int size) {
    return (T[]) Array.newInstance(clazz, size);
}

// 类型令牌模式（Type Token）
public abstract class TypeReference<T> {
    private final Type type;
    
    protected TypeReference() {
        Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }
    
    public Type getType() { return type; }
}

// 使用示例
Type mapType = new TypeReference<Map<String, Integer>>(){}.getType();

2. 复杂泛型设计模式

PECS原则（Producer-Extends, Consumer-Super）：

// 生产者使用extends（读取数据）
void processNumbers(List<? extends Number> numbers) {
    for (Number n : numbers) {
        System.out.println(n.doubleValue());
    }
}

// 消费者使用super（写入数据）
void populateIntegers(List<? super Integer> list) {
    for (int i = 0; i < 10; i++) {
        list.add(i); // 安全添加Integer
    }
}

---

六、总结与工程建议

1. 类型擦除的本质：Java泛型是编译期语法糖，运行时类型信息被擦除
2. 反射的边界：只能获取声明时的泛型信息，无法获取运行时实例类型
3. 工程化建议：
   • 在API设计中优先使用泛型提高类型安全
   • 避免在性能敏感区域使用深层嵌套泛型
   • 使用@SuppressWarnings("unchecked")时添加详细注释说明
   • 复杂泛型场景考虑使用Type Token或Gson的TypeToken实现
4. 替代方案：对类型信息有严格要求的场景，可考虑：
   • 代码生成（如AutoValue）
   • 字节码操作（ASM）
   • 其他JVM语言（Kotlin保留泛型类型信息）