一、什么是 Java 泛型？

泛型（Generics） 是 Java 1.5 引入的特性，允许在定义类、接口、方法时使用类型参数 ，从而实现类型安全的代码复用。泛型让开发者在编译时指定集合或类的具体类型，避免运行时类型转换错误，提高代码的可读性和安全性。

核心特点

• 类型安全：编译时检查类型错误，减少 ClassCastException。
• 代码复用：通过类型参数实现通用代码。
• 简化代码：无需显式类型转换。
• 类型擦除：编译后泛型信息被擦除，运行时不可见。

适用场景

• 集合框架（如 List<T>、Map<K,V>）。
• 自定义通用类（如工具类、容器类）。
• 框架开发（如 Spring、Hibernate）。
• 算法实现（如排序、查找）。

核心包

• java.util：集合框架大量使用泛型（如 ArrayList<T>）。
• java.lang.reflect：反射操作泛型类型。

二、泛型的基本语法

1. 泛型类

定义类时指定类型参数，格式为 class ClassName<T>。

// 定义泛型类 Box，T 是类型参数
public class Box<T> {
    private T content; // 成员变量使用类型参数 T

    // 构造器
    public Box(T content) {
        this.content = content;
    }

    // 获取内容
    public T getContent() {
        return content;
    }

    // 设置内容
    public void setContent(T content) {
        this.content = content;
    }

    public static void main(String[] args) {
        // 创建 Box<Integer> 实例，指定 T 为 Integer
        Box<Integer> intBox = new Box<>(42);
        System.out.println("Integer Box: " + intBox.getContent()); // 输出: 42

        // 创建 Box<String> 实例，指定 T 为 String
        Box<String> strBox = new Box<>("Hello");
        System.out.println("String Box: " + strBox.getContent()); // 输出: Hello

        // 编译错误：类型不匹配
        // Box<Integer> errorBox = new Box<>("Wrong"); // 编译错误

        // 注意事项：
        // - T 是占位符，编译时替换为具体类型
        // - 泛型类确保类型安全，无需强制转换
        // - 不能使用基本类型（如 int），需用包装类（如 Integer）
    }
}

注释说明：

• T 是类型参数，命名通常为大写字母（如 T、E、K、V）。
• 创建实例时指定具体类型（如 Box<Integer>）。
• 泛型类在编译时检查类型，防止错误赋值。

2. 泛型接口

定义接口时指定类型参数，格式为 interface InterfaceName<T>。

// 定义泛型接口 Container
public interface Container<T> {
    void add(T item); // 添加元素
    T get(); // 获取元素
}

// 实现泛型接口
class StringContainer implements Container<String> {
    private String item;

    @Override
    public void add(String item) {
        this.item = item;
    }

    @Override
    public String get() {
        return item;
    }
}

class Main {
    public static void main(String[] args) {
        // 创建 StringContainer 实例
        Container<String> container = new StringContainer();
        container.add("Hello");
        System.out.println("Container item: " + container.get()); // 输出: Hello

        // 编译错误：类型不匹配
        // container.add(123); // 编译错误

        // 注意事项：
        // - 实现泛型接口时必须指定具体类型（如 String）
        // - 也可以保持泛型，定义为 class MyContainer<T> implements Container<T>
        // - 泛型接口常用于集合框架（如 List<T>）
    }
}

注释说明：

• 泛型接口与泛型类类似，使用类型参数。
• 实现类可指定具体类型或继续使用泛型。
• 确保类型安全，防止非法类型操作。

3. 泛型方法

在方法中定义类型参数，格式为 <T> 返回类型 methodName(T param)。

public class GenericMethodExample {
    // 泛型方法，T 是方法级类型参数
    public static <T> void printArray(T[] array) {
        System.out.print("Array: ");
        for (T item : array) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    // 泛型方法，带返回值
    public static <T> T getFirst(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        return array[0];
    }

    public static void main(String[] args) {
        // 创建 Integer 数组
        Integer[] intArray = {1, 2, 3};
        printArray(intArray); // 输出: Array: 1 2 3

        // 创建 String 数组
        String[] strArray = {"A", "B", "C"};
        printArray(strArray); // 输出: Array: A B C

        // 调用泛型方法获取第一个元素
        String first = getFirst(strArray);
        System.out.println("First element: " + first); // 输出: First element: A

        // 注意事项：
        // - 泛型方法可在非泛型类中使用
        // - 类型参数 T 在方法调用时自动推断
        // - 编译器根据实参类型检查类型安全
    }
}

注释说明：

• 泛型方法独立于类级别泛型，类型参数作用于方法。
• 编译器自动推断类型（如 printArray(intArray) 推断为 Integer）。
• 可显式指定类型（如 <String>printArray(strArray)），但通常无需手动指定。

三、类型擦除（Type Erasure）

Java 泛型通过类型擦除实现，编译后泛型信息被擦除，运行时不可见。这是为了兼容 Java 1.5 之前的代码。

类型擦除规则

1. 替换类型参数：
   • 无界类型（如 T）替换为 Object。
   • 有界类型（如 T extends Number）替换为边界类型（如 Number）。
2. 插入类型转换：
   • 编译器在需要时插入强制类型转换。
3. 生成桥接方法：
   • 确保多态性，处理泛型继承。

import java.util.*;

public class TypeErasureExample {
    public static void main(String[] args) {
        // 创建泛型 List
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        System.out.println("String List: " + stringList); // 输出: [Hello]

        // 编译后等价于 List<Object>，类型擦除
        List rawList = stringList; // 原始类型
        rawList.add(123); // 运行时允许，但破坏类型安全
        System.out.println("Raw List: " + rawList); // 输出: [Hello, 123]

        // 运行时获取类型（无泛型信息）
        Class<?> clazz = stringList.getClass();
        System.out.println("Class: " + clazz.getName()); // 输出: java.util.ArrayList

        // 注意事项：
        // - 类型擦除导致运行时无法获取泛型类型（如 T）
        // - 原始类型（Raw Type）不安全，应避免使用
        // - 编译器插入类型转换确保类型安全
    }
}

注释说明：

• 类型擦除将 List<String> 编译为 List，T 替换为 Object。
• 原始类型（如 List）兼容旧代码，但可能引发运行时错误。
• 运行时无法通过反射获取具体泛型类型（如 String）。

四、通配符（Wildcard）

通配符用于处理泛型类型的灵活性，解决类型安全和继承问题。

1. 无界通配符（?）

表示任意类型，相当于 ? extends Object。

import java.util.*;

public class WildcardExample {
    // 接受任意类型的 List
    public static void printList(List<?> list) {
        System.out.print("List: ");
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 创建不同类型的 List
        List<Integer> intList = Arrays.asList(1, 2, 3);
        List<String> strList = Arrays.asList("A", "B", "C");

        // 使用无界通配符
        printList(intList); // 输出: List: 1 2 3
        printList(strList); // 输出: List: A B C

        // 注意事项：
        // - ? 表示任意类型，只能读取，不能修改（除 null）
        // - 编译器确保类型安全
        // - 适合通用方法，处理未知类型
    }
}

注释说明：

• List<?> 接受任意类型的 List，但只能读取（类型为 Object）。
• 无法添加元素（除 null），因具体类型未知。
• 适合只读场景。

2. 上界通配符（? extends T）

表示类型是 T 或其子类。

import java.util.*;

public class UpperBoundWildcardExample {
    // 接受 Number 或其子类的 List
    public static double sumList(List<? extends Number> list) {
        double sum = 0.0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        // 创建不同类型的 List
        List<Integer> intList = Arrays.asList(1, 2, 3);
        List<Double> doubleList = Arrays.asList(1.5, 2.5, 3.5);

        // 使用上界通配符
        System.out.println("Sum of Integer List: " + sumList(intList)); // 输出: 6.0
        System.out.println("Sum of Double List: " + sumList(doubleList)); // 输出: 7.5

        // 编译错误：不能添加元素
        // intList.add(4); // 编译错误，因类型未知

        // 注意事项：
        // - ? extends T 限制为 T 或子类，只能读取
        // - 适合消费数据（Consumer），如遍历、计算
        // - 无法添加元素（除 null），因具体子类型未知
    }
}

注释说明：

• List<? extends Number> 接受 Number 或其子类（如 Integer、Double）。
• 只能读取（作为 Number），不能写入（类型安全）。
• 常用于只读方法。

3. 下界通配符（? super T）

表示类型是 T 或其父类。

import java.util.*;

public class LowerBoundWildcardExample {
    // 向 List 添加 Integer 或其子类
    public static void addNumbers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public static void main(String[] args) {
        // 创建不同类型的 List
        List<Integer> intList = new ArrayList<>();
        List<Number> numList = new ArrayList<>();
        List<Object> objList = new ArrayList<>();

        // 使用下界通配符
        addNumbers(intList); // 有效，Integer 是 Integer 本身
        addNumbers(numList); // 有效，Number 是 Integer 的父类
        addNumbers(objList); // 有效，Object 是 Integer 的父类
        System.out.println("Integer List: " + intList); // 输出: [1, 2, 3]
        System.out.println("Number List: " + numList); // 输出: [1, 2, 3]
        System.out.println("Object List: " + objList); // 输出: [1, 2, 3]

        // 注意事项：
        // - ? super T 限制为 T 或父类，只能写入 T 类型
        // - 读取时类型为 Object，需转换
        // - 适合生产数据（Producer），如添加元素
    }
}

注释说明：

• List<? super Integer> 接受 Integer 或其父类（如 Number、Object）。
• 可以写入 Integer 类型，读取时视为 Object。
• 常用于写入场景。

4. PECS 原则

PECS：Producer Extends, Consumer Super。

• Producer（生产者）：用 ? extends T，只读数据。
• Consumer（消费者）：用 ? super T，只写数据。

五、泛型边界（Bounded Types）

泛型支持类型边界，限制类型参数的范围。

1. 上界（T extends Class/Interface）

类型参数必须是指定类/接口或其子类。

public class BoundedTypeExample {
    // 泛型类，T 必须是 Number 或其子类
    static class NumberBox<T extends Number> {
        private T value;

        public NumberBox(T value) {
            this.value = value;
        }

        public double doubleValue() {
            return value.doubleValue(); // 调用 Number 的方法
        }
    }

    public static void main(String[] args) {
        // 创建 NumberBox 实例
        NumberBox<Integer> intBox = new NumberBox<>(42);
        NumberBox<Double> doubleBox = new NumberBox<>(3.14);
        System.out.println("Integer Box: " + intBox.doubleValue()); // 输出: 42.0
        System.out.println("Double Box: " + doubleBox.doubleValue()); // 输出: 3.14

        // 编译错误：String 不是 Number 的子类
        // NumberBox<String> strBox = new NumberBox<>("Invalid"); // 编译错误

        // 注意事项：
        // - T extends Number 限制类型范围
        // - 可使用 Number 的方法（如 doubleValue）
        // - 支持多个边界：T extends Number & Comparable<T>
    }
}

注释说明：

• T extends Number 限制 T 为 Number 或子类。
• 可访问边界类的方法（如 doubleValue）。
• 支持多重边界（如 T extends Number & Comparable<T>），但只能一个类，多个接口。

2. 下界（? super T）

已在通配符部分说明，适用于方法参数。

六、泛型与继承

泛型类型之间的继承关系需要特别注意。

import java.util.*;

public class GenericInheritanceExample {
    public static void main(String[] args) {
        // List<String> 不是 List<Object> 的子类型
        List<String> strList = new ArrayList<>();
        strList.add("Hello");
        // List<Object> objList = strList; // 编译错误

        // 使用通配符解决继承问题
        List<? extends Object> objList = strList; // 合法，String 是 Object 子类
        System.out.println("First element: " + objList.get(0)); // 输出: Hello

        // 父类引用指向子类对象
        ArrayList<String> arrayList = new ArrayList<>();
        List<String> list = arrayList; // 合法，ArrayList 是 List 的子类
        list.add("World");
        System.out.println("List: " + list); // 输出: [World]

        // 注意事项：
        // - List<String> 和 List<Object> 无继承关系
        // - 使用 ? extends T 或 ? super T 处理继承
        // - 泛型类本身的继承关系正常（如 ArrayList<T> 是 List<T> 的子类）
    }
}

注释说明：

• 泛型类型不具有协变性（如 List<String> 不是 List<Object> 的子类型）。
• 通配符（? extends T、? super T）解决继承问题。
• 泛型类的实现/继承关系与非泛型类一致。

七、泛型与反射

由于类型擦除，运行时无法直接获取泛型类型，但可以通过反射获取部分信息（如泛型参数）。

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

public class GenericReflectionExample {
    // 泛型类
    static class GenericClass<T> {
        private T value;
        public GenericClass(T value) {
            this.value = value;
        }
    }

    public static void main(String[] args) {
        try {
            // 获取 GenericClass 的 Class 对象
            Class<?> clazz = GenericClass.class;

            // 获取泛型超类
            Type genericSuperclass = clazz.getGenericSuperclass();
            System.out.println("Generic Superclass: " + genericSuperclass); // 输出: java.lang.Object

            // 获取字段的泛型类型
            Field field = clazz.getDeclaredField("value");
            Type genericType = field.getGenericType();
            System.out.println("Field Generic Type: " + genericType); // 输出: T

            // 获取具体实例的泛型信息
            GenericClass<String> strInstance = new GenericClass<>("Test");
            Class<?> instanceClass = strInstance.getClass();
            System.out.println("Instance Class: " + instanceClass.getName()); // 输出: GenericClass

            // 注意事项：
            // - 类型擦除导致运行时无法获取 T 的具体类型
            // - 可通过 getGenericType 获取参数化类型
            // - 反射常用于框架（如 Spring 解析泛型依赖）
        } catch (NoSuchFieldException e) {
            System.err.println("Field not found: " + e.getMessage());
        }
    }
}

注释说明：

• 类型擦除使运行时泛型信息有限。
• getGenericType 获取字段/方法的泛型签名。
• 反射用于框架解析泛型（如 Spring 的 @Autowired）。

八、常见问题与优化

1. 常见问题

类型擦除

• 运行时无法获取具体类型，导致反射复杂。
• 解决：使用 Type 接口（如 ParameterizedType）或注解传递类型信息。

原始类型（Raw Type）

• 使用 List 而非 List<T> 不安全，可能导致运行时错误。
• 解决：始终指定泛型类型。

泛型数组

• 不能创建泛型数组（如 T[]），因类型擦除。
• 解决：使用 Object[] 并转换，或用 ArrayList<T>。

T[] array = (T[]) new Object[10]; // 合法但有警告

边界复杂性

• 多重边界或嵌套泛型（如 List<List<T>>）增加代码复杂性。
• 解决：简化设计，使用清晰命名。

2. 优化建议

1. 明确类型参数：
   • 避免原始类型，始终指定泛型（如 List<String>）。
2. 使用通配符：
   • 根据 PECS 原则选择 extends 或 super。
3. 缓存泛型信息：
   • 在反射场景中缓存 ParameterizedType。
4. 简化泛型：
   • 避免过度嵌套，保持代码可读。
5. 静态泛型方法：
   • 优先使用泛型方法，减少类级别泛型。

九、实际应用场景示例

以下是一个综合示例，模拟一个泛型工具类，用于处理集合的过滤和转换。

import java.util.*;
import java.util.function.Predicate;

public class GenericUtilExample {
    // 泛型方法：过滤集合
    public static <T> List<T> filterList(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }

    // 泛型方法：转换集合
    public static <T, R> List<R> mapList(List<T> list, Function<T, R> mapper) {
        List<R> result = new ArrayList<>();
        for (T item : list) {
            result.add(mapper.apply(item));
        }
        return result;
    }

    public static void main(String[] args) {
        // 创建测试数据
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 过滤：获取偶数
        List<Integer> evenNumbers = filterList(numbers, n -> n % 2 == 0);
        System.out.println("Even Numbers: " + evenNumbers); // 输出: [2, 4]

        // 转换：将数字转为字符串
        List<String> strNumbers = mapList(numbers, n -> "Num-" + n);
        System.out.println("Mapped Numbers: " + strNumbers); // 输出: [Num-1, Num-2, Num-3, Num-4, Num-5]

        // 过滤：获取长度 > 3 的名字
        List<String> longNames = filterList(names, s -> s.length() > 3);
        System.out.println("Long Names: " + longNames); // 输出: [Alice, Charlie]

        // 注意事项：
        // - 泛型方法提高代码复用性
        // - Predicate 和 Function 结合泛型，功能强大
        // - 类型安全由编译器保证
    }
}

注释说明：

• 模拟通用工具类，处理集合的过滤和转换。
• 使用 Predicate 和 Function 增强灵活性。
• 泛型方法支持任意类型，类型安全由编译器保证。
• 类似 Java Stream API 的实现原理。

十、总结

Java 泛型是类型安全的强大工具，提供以下功能：

1. 基本语法：
   • 泛型类（class Box<T>）、接口（interface Container<T>）、方法（<T> void method(T t)）。
   • 类型参数（如 T、E）在编译时指定具体类型。
2. 类型擦除：
   • 编译后擦除泛型信息，替换为 Object 或边界类型。
   • 运行时无法获取具体类型，需通过反射或注解。
3. 通配符：
   • 无界（?）：任意类型，只读。
   • 上界（? extends T）：T 或子类，只读。
   • 下界（? super T）：T 或父类，可写。
   • PECS 原则：Producer Extends, Consumer Super。
4. 边界：
   • 上界（T extends Number）：限制类型范围。
   • 多重边界（T extends Number & Comparable<T>）。
5. 泛型与继承：
   • 泛型类型无协变性，需用通配符处理。
   • 泛型类继承正常。
6. 泛型与反射：
   • 类型擦除限制运行时信息。
   • 使用 ParameterizedType 获取泛型签名。
7. 常见问题：
   • 类型擦除、原始类型、泛型数组。
   • 解决：明确类型、避免 Raw Type、使用 List 替代数组。
8. 应用场景：
   • 集合框架、工具类、框架开发。
   • 泛型方法实现通用算法。