Java 泛型深度解析：机制、边界与实战

如果尝试传入不兼容的类型（如 String），编译器会直接报错。

在实际业务中，泛型上界常用于需要调用特定方法的场景。例如，寻找数组中的最大值，元素必须可比较：

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

类型擦除

Java 的泛型实现依赖于'类型擦除'（Type Erasure）。这是理解 Java 泛型行为的关键：编译器在编译阶段检查类型安全，但在生成字节码时，会移除所有泛型类型信息。

擦除过程详解

1. 移除类型参数：泛型类型参数被替换为其上界。如果没有指定上界，则默认为 Object。
   • List<String> 和 List<Integer> 在运行时都表现为 List。
   • T extends Comparable<T> 中的 T 会被替换为 Comparable。
2. 插入类型转换：编译器会在读取元素的地方自动插入强制类型转换，以恢复类型安全。
3. 桥接方法：为了保持与旧版本非泛型代码的兼容性，编译器可能会生成桥接方法（Bridge Methods）。

这意味着在运行时，JVM 无法区分 List<String> 和 List<Integer>，它们都是原始类型 List。这也解释了为什么我们不能在运行时获取泛型的具体类型参数。

通配符

当不确定具体类型，但又想利用泛型特性时，可以使用通配符 ?。

通配符上界 (? extends T)

主要用于读取数据（Producer Extends）。它表示未知类型，但该类型必须是 T 或其子类。

• 特点：可以安全地读取元素，但不能向集合中添加任何对象（除了 null）。因为编译器不知道具体是 T 还是其子类，添加操作可能破坏类型安全。

class Food { }
class Fruit extends Food { }
class Apple extends Fruit { }

class Message<T> {
    private T message;
    public T getMessage() { return message; }
    public void setMessage(T message) { this.message = message; }
}

public class Test {
    // 接受任意 Fruit 及其子类的 Message
    public static void funExtends(Message<? extends Fruit> temp) {
        System.out.println(temp.getMessage());
        // temp.setMessage(new Banana()); // 编译错误
        Fruit fruit = temp.getMessage(); // 安全读取
    }
}

通配符下界 (? super T)

主要用于写入数据（Consumer Super）。它表示未知类型，但该类型必须是 T 或其父类。

• 特点：可以向集合中添加 T 或其子类，但读取时只能得到 Object 类型，因为具体是哪个父类不确定。

class Plate<T> {
    private T plate;
    public T getPlate() { return plate; }
    public void setPlate(T plate) { this.plate = plate; }
}

public class Test {
    // 接受 Fruit 或其父类的 Plate
    public static void funSuper(Plate<? super Fruit> temp) {
        temp.setPlate(new Apple()); // 安全写入
        temp.setPlate(new Banana()); // 安全写入
        Object obj = temp.getPlate(); // 只能接收 Object
    }
}

记住一个原则：PECS (Producer Extends, Consumer Super)。如果需要从结构中取数据，用 extends；如果需要往结构中放数据，用 super。

泛型方法

泛型方法独立于类存在，可以在静态上下文中使用。方法声明时需在返回值前加上类型参数列表。

class Alg2 {
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1, 13, 51, 71, 19};
        Integer ret = Alg2.<Integer>findMax(array);
        System.out.println(ret);
    }
}

泛型的限制

尽管泛型很强大，但受限于类型擦除，使用时有一些硬性约束：

1. 不能使用基本数据类型：泛型参数必须是引用类型。需用包装类替代（如 Integer 代替 int）。
2. 不能创建泛型数组：new List<String>[10] 是非法的。建议使用 ArrayList<List<String>> 等集合嵌套。
3. 不能实例化泛型类型：new List<String>() 不行，必须实例化具体类，如 new ArrayList<>()。
4. 运行时类型查询受限：由于擦除，instanceof 和 getClass() 无法检测泛型参数的具体类型。
5. 泛型类型无继承关系：即使 A 是 B 的子类，List<A> 也不是 List<B> 的子类。这要求开发者注意类型转换。
6. 反射限制：反射无法直接获取泛型类型参数的具体信息，需结合注解或特殊处理。

掌握这些限制和机制，能帮助我们在设计 API 和重构代码时做出更明智的选择，写出既安全又灵活的 Java 程序。