Java泛型实用理解：擦除、通配符与限制

像 Collections.max() 那种求最大值的方法，就需要元素实现 Comparable。通常写成这样：

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;
    }
}

类型擦除：编译时擦光，运行时只剩Object

Java泛型最核心的实现方式就是类型擦除。编译后，List<String> 和 List<Integer> 在字节码里都变成了 List。JVM根本不知道当初你写的是String还是Integer。

这带来了向后兼容的优点，也带来了很多需要手动处理的地方：

1. 移除类型参数：字节码不保留泛型信息。
2. 替换为上界或Object：参数被替换为上界类型（比如 Comparable），没设上界就替换成 Object。
3. 插入强制转型：你从容器里取元素时，编译器自动插入从 Object 到目标类型的转型。
4. 桥接方法：为了兼容老代码，有时会生成桥接方法处理泛型方法覆盖。

这套机制意味着运行时没法直接拿到泛型的具体类型，很多看起来该成立的事情做不了。

通配符：该读还是该写，搞清楚边界

当你写一个方法，想接受任意泛型参数的 Message 时，可以用无界通配符 ?：

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

public class Test {
    public static void fun(Message<?> temp) {
        System.out.println(temp.getMessage());
    }
    
    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.setMessage("你好！");
        fun(message);
        
        Message<Integer> message2 = new Message<>();
        message2.setMessage(199);
        fun(message2);
    }
}

但无界通配符太宽了，没法往里写。要灵活一点，得靠上下界。

上界通配符 ? extends T：只读

这种写法表示某种不确定的T子类，你只能从里面拿东西，不能往里塞。典型的Producer角色。

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

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

public class Test1 {
    public static void funExtends(Message<? extends Fruit> temp) {
        System.out.println(temp.getMessage());
        // 不能调用setMessage，因为不知道具体是Apple还是Banana
        // temp.setMessage(new Banana());
        
        Fruit fruit = temp.getMessage(); // 向上转型接收
    }
}

下界通配符 ? super T：只写

反过来，? super Fruit 表示某种Fruit的父类，你可以放心往里加Fruit及其子类，但取出来只能当作Object。Consumer角色。

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

public class Test1 {
    public static void funSuper(Plate<? super Fruit> temp) {
        temp.setPlate(new Apple());
        temp.setPlate(new Banana());
        
        System.out.println(temp.getPlate()); // 只能当Object用
    }
}

记住PECS（Producer Extends Consumer 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 Test2 {
    public static void main(String[] args) {
        Integer[] array = {1, 13, 51, 71, 19};
        Integer ret = Alg2.<Integer>findMax(array);
        System.out.println(ret);
    }
}

调用时显式指定 <Integer> 不是必须的，编译器一般能推断出来。

这几个限制，都是擦除的锅

泛型好用，但限制也不少，根源几乎全在类型擦除：

1. 基本类型必须装箱：泛型只接受引用类型，int 得用 Integer，这是擦除替换为 Object 的代价。
2. 不能创建泛型数组：new List<String>[10] 编译不过，用 ArrayList<List<String>> 迂回一下。
3. 不能直接实例化泛型对象：new T() 非法，运行时根本不知道T是什么。
4. instanceof 和 getClass() 查不了泛型：运行时所有 List<Whatever> 都是同一个 List.class。
5. 泛型类型没有父子关系：List<Apple> 和 List<Fruit> 无关，即便 Apple 继承 Fruit。这就是协变 / 逆变问题的源头。
6. 反射拿不到完整泛型信息：擦除把参数类型信息丢了，想获取得靠一些特殊的 hack（比如取得匿名类的泛型父类）。

理解这些限制的来由，比背下它们更重要。每次写新类时，想想'它被擦除后是什么样'，很多设计上的纠结自然就解开了。