1. 回顾那堵墙：泛型不传递

8.1 说过：Integer 是 Number 的子类，但 Box<Integer> 不是 Box<Number> 的子类——泛型没有"传递继承"。这带来一个实际难题：

public static void print(Box<Object> box) { }   // 想通吃

Box<String> bs = new Box<>();
print(bs);   // ✗ 编译报错——Box<String> 和 Box<Object> 平级，传不进去

想把"打印任意 Box"写成一个方法，难道每种类型重载一遍？? 通配符就是官方拆墙方案。

2. 无界通配符 ?：未知类型，啥都收

? 读作"某种未知的类型"——写在使用的地方（不是类上、不是方法上）：

public static void printAll(Box<?> box) {       // 任意 Box<?> 都能传
    System.out.println(box.get());              // 读：没问题
}

printAll(new Box<String>());    // ✓
printAll(new Box<Integer>());   // ✓  一份代码通吃

3. 上界通配符 ? extends：只要这一家的

? extends Number = "Number 或它的某个子类，具体是谁未知"。能收紧读的类型：

public static double sum(List<? extends Number> list) {
    double total = 0;
    for (Number n : list) {       // 读 ✓：保证是 Number，直接用
        total += n.doubleValue();
    }
    return total;
}

sum(new ArrayList<Integer>());    // ✓
sum(new ArrayList<Double>());     // ✓  Number 一家子全收

// 但写照样被锁：
list.add(1);   // ✗ 编译报错——? 可能是 Double，塞 Integer 就乱了

为什么连 add(1) 都不行？List<? extends Number> 可能实际是 List<Double>——往 Double 列表里塞 Integer 当然犯规。编译器干脆一刀切：extends 门只读不写（null 除外）。

4. 下界通配符 ? super：这一家都能装

? super Integer = "Integer 或它的某个祖先，具体是谁未知"。写的权利回来了：

public static void fill(List<? super Integer> list) {
    list.add(1);       // 写 ✓：Integer 塞进 Integer/Number/Object 容器都安全
    list.add(42);
}

fill(new ArrayList<Integer>());   // ✓
fill(new ArrayList<Number>());    // ✓  祖先容器也收
fill(new ArrayList<Object>());    // ✓

// 读出来只能当 Object（不知道容器到底是什么祖先）：
Integer x = list.get(0);          // ✗ 编译报错
Object y = list.get(0);           // ✓

逻辑自洽：容器保证"至少能装 Integer"，那往里塞 Integer（及子类）永远安全；但取出来时不知道具体是谁，只能按 Object 接。

5. PECS 口诀 + JDK 实例

三种门的读写权限一张表收拢（以 ? super/extends Integer 或 Number 为例）：

PECS 口诀（会认级）：Producer Extends，Consumer Super——参数要往外生产数据就用 extends，要往里消费数据就用 super。

JDK 里的标准示范（7.7 见过 Collections.copy，现在能看懂签名了）：

copy(List<? super T> dest, List<? extends T> src)
//      消费者：只往里装        生产者：只往外给
// 权限分配严丝合缝——读写按需收紧，正是通配符的价值

6. 动手时间（Demo05）

import java.util.*;

public class Demo05 {
    // 生产者：只读——Number 一家子的和
    public static double sum(List<? extends Number> list) {
        double total = 0;
        for (Number n : list) {
            total += n.doubleValue();
        }
        return total;
    }

    // 消费者：只写——往 Integer 的任意祖先容器里填数
    public static void fill(List<? super Integer> list, int count) {
        for (int i = 1; i <= count; i++) {
            list.add(i);
        }
    }

    // 无界：只看——打印任意 List
    public static void printAll(List<?> list) {
        for (Object item : list) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        List<Integer> ints = new ArrayList<>(List.of(88, 95, 76));
        List<Double> doubles = new ArrayList<>(List.of(1.5, 2.5));

        System.out.println("整数和: " + sum(ints));       // ✓
        System.out.println("小数和: " + sum(doubles));    // ✓ 同一个方法通吃

        List<Number> nums = new ArrayList<>();
        fill(nums, 3);                                    // ✓ 往祖先容器填
        printAll(nums);
    }
}

7. 30 秒实验

实验 1：printAll 参数写 Box<Object> 再传 Box<String>——编译报错（那堵墙）；改成 Box<?> 立即通过——亲眼见拆墙。

实验 2：Box<?> box 上调 box.set("波仔")——编译报错；box.set(null) 却能过——能看不能摸的唯一例外。

实验 3：List<? extends Number> 上 add(1)——编译报错；读出来赋给 Number n 通过——只读门生效。

实验 4：List<? super Integer> 上 add(1) 通过；读出来赋给 Integer 报错、赋给 Object 通过——只写门生效。

实验 5：List<Object> lo = new ArrayList<String>();——编译报错（那堵墙还在）；List<?> lq = new ArrayList<String>();——通过。<?> 和 <Object> 是两码事。

8. 常见误区

1. 以为 List<Object> 能收 List<String>——泛型不传递，<Object> 只是一个具体类型；能通吃的只有 List<?>。
2. 往 ? extends 容器里 add——即使塞"看起来兼容"的类型也报错；extends 门只读（null 除外）。
3. 从 ? super 容器读出来当具体类型——只能当 Object 接；要具体类型得强转（那就失去泛型意义了）。
4. 把 ? 写在类或方法声明上——class Box<?> ✗；? 只写在使用的类型里（变量、参数、返回值）。
5. 以为 ? 等于 <T> 的简写——<T> 是"占位符，等我定型"，? 是"未知，永远不定型"；泛型方法要读写操作数据用 <T>，只要兼容传参用 ?。
6. 三扇门乱选——先问这个参数"我只读还是只写"：只读 extends、只写 super、都要动就别用 ?（用 <T> 或具体类型）。

9. 折叠自测题