训练与减脂笔记

从 getClass 说起：理解 Class 对象与泛型擦除

akm — Tue, 15 Sep 2026 00:00:00 GMT

所属：Java 面试笔记 / 01-Java基础 / 01-泛型｜学习计划：D1 前置：无｜后续：02-擦除之后（这篇讲「擦除是什么」，那篇讲「擦除之后怎么办」）

0. 本文要解决什么

面试里问泛型擦除，很多人上来就背"运行时被擦除"。但如果你连 getClass() 返回的是什么、Class 对象是什么都说不清，后面全是空中楼阁。

本文从 getClass() 切入，把下面这条链讲透：

getClass() → Class 对象 → 运行时真实类型 → 泛型擦除

学完你应该能回答：

getClass() 返回什么？
同一个类的 Class 对象是不是同一个？
getClass()、.class、instanceof 有什么区别？
为什么 List<String> 和 List<Integer> 的 getClass() 相等？
泛型信息到底还在不在？

1. getClass() 是什么

getClass() 定义在 Object 里：

public final native Class<?> getClass();

拆开看：

修饰	含义
`public`	所有类都能调用
`final`	不能被子类重写
`native`	由 JVM 底层实现
返回 `Class<?>`	返回运行时真实类型对应的 Class 对象

示例：

String s = "abc";
Class<?> c = s.getClass();
System.out.println(c.getName()); // java.lang.String

一句话：getClass() 返回对象在运行时的真实类型对应的 Class 对象。

2. Class 对象是什么

JVM 加载每个类时，会在方法区（JDK 8+ 是 Metaspace）里为它建立一份类元数据，同时在堆上创建一个 java.lang.Class 对象作为这份元数据的入口。我们平时拿到的就是这个 Class 对象，它对外暴露：

类名、包名
父类、实现的接口
字段、方法、构造器
注解
泛型签名（部分）

可以把它理解成：某个类在内存里的说明书。

Class<?> c = String.class;
System.out.println(c.getName());       // java.lang.String
System.out.println(c.getSimpleName()); // String
System.out.println(c.getSuperclass()); // class java.lang.Object

Class 本身也是类，全名 java.lang.Class。Class 对象也是对象，只不过它代表的是"类"。

面试加分点：严格说，类元数据在 Metaspace 的 InstanceKlass 里，堆上的 Class 对象只是它的镜像（HotSpot 中 Class 对象的 _klass 指针回指 InstanceKlass）。说"Class 对象保存在方法区"是不准确的——它是堆对象，强引用着方法区的元数据。

3. 同一个类只有一个 Class 对象

在同一个类加载器下，一个类只会对应一个 Class 对象。

String s1 = "a";
String s2 = "b";
System.out.println(s1.getClass() == s2.getClass()); // true

String s = "abc";
System.out.println(s.getClass() == String.class); // true

补充：不同类加载器加载同一个类名，会得到不同的 Class 对象。这是类加载隔离的基础，后面 JVM 篇再展开。

4. getClass()、.class、instanceof 的区别

String s = "abc";

Class<?> c1 = s.getClass();      // 运行时通过对象获取
Class<?> c2 = String.class;      // 编译期类字面量
boolean b = s instanceof String; // 判断是不是某类型（含子类）

写法	时机	判断依据	是否含子类
`obj.getClass()`	运行时	真实类型	否，精确匹配
`X.class`	编译期	类字面量	—
`obj instanceof X`	运行时	是否属于 X 或子类	是

关键对比：

Object o = new String("abc");

System.out.println(o instanceof String);          // true
System.out.println(o.getClass() == String.class); // true
System.out.println(o.getClass() == Object.class); // false

o 的静态类型是 Object，运行时真实类型是 String。getClass() 看运行时真实类型，所以返回 String.class。

5. 泛型擦除

Java 泛型是编译期的。编译完之后，泛型参数被擦除，运行时不存在。

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();

编译后，字节码里都是原始类型（raw type）：

List a = new ArrayList();
List b = new ArrayList();

擦除规则（擦到第一个上界）：

声明	擦除后
`<T>`	`Object`
`<T extends Number>`	`Number`
`<T extends Comparable<T>>`	`Comparable`

class Box<T> { T value; }
// 擦除后 ≈ class Box { Object value; }

class NumBox<T extends Number> { T value; }
// 擦除后 ≈ class NumBox { Number value; }

一句话：泛型是给编译器看的，运行时不存在。

6. 为什么 `List<String>` 和 `List<Integer>` 的 getClass() 相等

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();

System.out.println(a.getClass());                 // class java.util.ArrayList
System.out.println(b.getClass());                 // class java.util.ArrayList
System.out.println(a.getClass() == b.getClass()); // true
System.out.println(a.getClass() == List.class);   // false
System.out.println(a instanceof List);            // true

逐条解释：

a、b 都是 new ArrayList<>() 创建，运行时真实类型都是 ArrayList。
同一个类加载器下，ArrayList 只有一个 Class 对象。
所以 a.getClass() == b.getClass() 为 true。
a.getClass() 是 ArrayList.class，不是 List.class，所以和 List.class 不等。
a instanceof List 为 true，因为 ArrayList 实现了 List。

核心结论：泛型参数不影响运行时类型，getClass() 只看真实类。

7. 泛型信息真的全没了吗

不是。分两个层面：

层面	泛型信息
对象实例	没有
类文件声明（字段、方法、父类）	可能保留在 `Signature` 属性里
反射读取声明处	可以读到

示例：

public class Demo {
    private List<String> names;
}

Field f = Demo.class.getDeclaredField("names");

System.out.println(f.getType());        // interface java.util.List
System.out.println(f.getGenericType()); // java.util.List<java.lang.String>

getType()：擦除后的原始类型 List。
getGenericType()：带泛型签名的 ParameterizedType。

进一步拿泛型参数：

if (f.getGenericType() instanceof ParameterizedType) {
    ParameterizedType pt = (ParameterizedType) f.getGenericType();
    Type[] args = pt.getActualTypeArguments();
    System.out.println(args[0]); // class java.lang.String
}

JDK 16+ 可以写成 instanceof ParameterizedType pt 的模式匹配，省掉强转。

这和 Spring 依赖注入是什么关系（一个常见错误说法）

不少笔记写"Spring 通过 getGenericType 知道要注入 UserService"，这是错的：

@Autowired
private UserService userService; // 这个字段根本没有泛型参数

这里 Spring 用的是 Field.getType()（即 UserService.class）做 byType 匹配，和 getGenericType 无关。

getGenericType 真正起作用的场景是字段类型本身带类型参数时：

@Autowired
private List<UserService> services;      // 要先知道元素类型，才能筛出候选 bean

@Autowired
private Repository<User> userRepository; // Spring Data 按泛型生成代理

abstract class BaseService<T> {          // 泛型父类声明的字段，
    @Autowired                           // 需要沿继承链解析 T
    protected T dao;
}

这些场景 Spring 走的是 ResolvableType：内部会调 getGenericType()，并把父类/接口上的类型变量一并解析出来，而不是简单看 getType()。

一句话：getType() 拿擦除后的类型，getGenericType() 拿带签名的类型；Spring 只在需要解析类型参数时才用后者。

8. 为什么不能 new T[]

class Box<T> {
    T[] arr = new T[10]; // 编译不通过
}

原因有两层：

数组是具体化类型（reified）：数组在运行时必须知道元素类型，才能做存取检查（ArrayStoreException 就是这么来的）。
泛型被擦除：运行时不知道 T 是什么，JVM 无法创建"类型正确"的数组。

而且数组是协变的（String[] 是 Object[] 的子类型），泛型是不变的，两者混用会破坏类型安全，所以 Java 直接从编译期禁止。

硬写：

T[] arr = (T[]) new Object[10]; // 编译警告，运行时堆污染

这叫堆污染。运行时它只是 Object[]，你往里放 String，别人当成 Integer[] 用就会 ClassCastException：

static <T> T[] wrong() {
    return (T[]) new Object[]{"a", "b"}; // 擦除后退化为 Object[]
}

Integer[] ints = wrong(); // 运行时 ClassCastException

正确做法：

T[] arr = (T[]) Array.newInstance(clazz, 10);

clazz 是 Class<T>，从外部传入。这也是很多框架要求传 Class 对象的原因。

另外，可变参数 T... 底层也是数组，编译器同样会给警告；@SafeVarargs 能抑制警告的前提是方法不往这个数组里写东西。完整实验见 02-擦除之后。

9. 擦除带来的两个连锁反应

9.1 重载冲突

擦除后签名相同，编译直接报错：

void m(List<String> a) {}
void m(List<Integer> b) {} // 编译错误：name clash，擦除后都是 m(List)

想区分只能换方法名，或者把参数容器换成不同类型。

9.2 桥方法（bridge method）

class Node<T> {
    public T get() { return null; }
}

class StringNode extends Node<String> {
    @Override
    public String get() { return "s"; }
}

擦除后父类方法签名是 Object get()。为了让"父类引用调用子类实现"的多态成立，编译器会在子类合成一个桥方法：

class StringNode extends Node<String> {
    public String get() { return "s"; }

    // 编译器合成，字节码里真实存在
    // public Object get() { return this.get(); }
}

用 javap -c -p StringNode 能看到两个 get。这解释了"重写后反射 getDeclaredMethods() 为什么会多一个方法"，也是"泛型擦除后多态仍然有效"的底层原因。字节码长什么样、Method.isBridge() 怎么用，见 02-擦除之后。

10. 完整验证代码

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class ErasureDemo {

    public static void main(String[] args) throws Exception {
        test1();
        test2();
        test3();
        test4();
    }

    // getClass / .class / instanceof
    static void test1() {
        Object o = new String("abc");
        System.out.println(o instanceof String);          // true
        System.out.println(o.getClass() == String.class); // true
        System.out.println(o.getClass() == Object.class); // false
    }

    // 泛型擦除
    static void test2() {
        List<String> a = new ArrayList<>();
        List<Integer> b = new ArrayList<>();

        System.out.println(a.getClass());                 // class java.util.ArrayList
        System.out.println(b.getClass());                 // class java.util.ArrayList
        System.out.println(a.getClass() == b.getClass()); // true
        System.out.println(a.getClass() == List.class);   // false
        System.out.println(a instanceof List);            // true
    }

    // 反射读取声明处泛型
    public static class Demo {
        private List<String> names;
    }

    static void test3() throws Exception {
        Field f = Demo.class.getDeclaredField("names");
        System.out.println(f.getType());        // interface java.util.List
        System.out.println(f.getGenericType()); // java.util.List<java.lang.String>

        if (f.getGenericType() instanceof ParameterizedType pt) {
            Type[] args = pt.getActualTypeArguments();
            System.out.println(args[0]); // class java.lang.String
        }
    }

    // 堆污染：能编译，运行时才炸
    @SuppressWarnings("unchecked")
    static <T> T[] wrong() {
        return (T[]) new Object[]{"a", "b"};
    }

    static void test4() {
        try {
            Integer[] ints = wrong();
            System.out.println(ints[0]);
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: " + e.getMessage());
        }
    }
}

javac -Xlint:unchecked ErasureDemo.java 会提示 test4 里的堆污染。test1 里的 new String("abc") 只是为了制造"静态类型 ≠ 运行时类型"的对比，真实代码里不要这么写。

11. 面试问法

Q1：getClass() 返回什么？

返回对象运行时真实类型对应的 Class 对象。同一个类加载器下，一个类只有一个 Class 对象。

Q2：getClass()、.class、instanceof 有什么区别？

getClass() 运行时通过对象拿真实类型，精确匹配、不含子类；.class 是编译期类字面量；instanceof 运行时判断是否属于某类型或子类。

Q3：为什么 List<String> 和 List<Integer> 的 getClass() 相等？

泛型编译期被擦除，运行时 a、b 都是 ArrayList 实例；同一个类加载器下 ArrayList 只有一个 Class 对象，所以相等。

Q4：泛型信息运行时真的没有吗？

对象实例上没有。但字段、方法、父类声明处的泛型签名保留在 Class 文件的 Signature 属性里，通过 getGenericType() 等反射 API 可以读到。注意：Spring 的普通字段注入用的是 getType()，不是 getGenericType()；后者只在解析类型参数（List<UserService>、Repository<User>、泛型父类字段）时才用得上。

Q5：为什么不能 new T[]？

数组是具体化类型，运行时需要元素类型来做存取检查；泛型被擦除，运行时不知道 T。要创建泛型数组得用 Array.newInstance(clazz, n) 显式传 Class，否则 (T[]) new Object[n] 只是把风险推迟成堆污染。

Q6：Java 为什么要擦除泛型？

向后兼容。泛型是 Java 5 引入的，为了不改 JVM 指令集、让新代码能和老库（List、Collection 这类没有泛型的旧字节码）在同一套类型系统里互操作，语言层选择了"编译期检查 + 运行期擦除"。代价就是运行时拿不到泛型实参，才会有 new T[] 被禁止、重载冲突、需要桥方法这些现象。

Q7：擦除带来了哪些连锁问题？

四类：① 运行时无法判断泛型实参（instanceof List<String> 非法）；② 不能创建泛型数组（new T[]）；③ 擦除后签名相同导致重载冲突（m(List<String>) 与 m(List<Integer>) 不能共存）；④ 子类重写泛型方法时编译器要合成桥方法维持多态。

12. 小结

getClass() 返回运行时真实类型的 Class 对象；同一个类加载器下，一个类只有一个 Class 对象。
Class 对象是堆对象，类元数据本体在 Metaspace 的 InstanceKlass 里。
泛型是编译期的，运行时被擦除，擦到第一个上界。
List<String> 和 List<Integer> 的实例运行时都是 ArrayList，getClass() 相等。
声明处的泛型签名保留在 Class 文件里，反射可读；但 Spring 普通字段注入用的是 getType()。
不能 new T[]，要 Array.newInstance(clazz, n)。
擦除的连锁反应：重载冲突、桥方法、堆污染、无法 instanceof 泛型实参。

记忆钩子一句话："泛型只活在编译期，Class 对象只认运行时真实类型。"

13. 下一步

[ ] 手跑第 10 节代码（含 javac -Xlint:unchecked），确认全部输出。
[ ] 用 javap -c -p 看一眼桥方法的字节码。
[ ] 闭卷复述第 11 节 7 个问题。
[ ] 写下一篇：02-擦除之后——桥方法字节码、重载冲突、堆污染完整实验、泛型数组与 @SafeVarargs、instanceof 泛型实参、静态成员为什么不能用 T。

擦除之后：桥方法、重载冲突与堆污染

akm — Tue, 15 Sep 2026 00:00:00 GMT

所属：Java 面试笔记 / 01-Java基础 / 01-泛型｜学习计划：D1 前置：01-从getClass说起｜后续：03-通配符与PECS（这篇讲擦除的补偿机制，那篇讲编译期怎么用通配符表达读写方向）

0. 本文要解决什么

上一篇讲的是擦除是什么：泛型只活在编译期，运行时 List<String> 和 List<Integer> 都是 List。

这一篇讲擦除之后怎么办。既然运行时没有泛型信息，那下面这些事编译器是怎么兜住的：

list.get(0) 返回的是 Object，为什么能直接赋给 String？
子类重写了泛型方法，多态为什么还能成立？
为什么两个只差泛型参数的方法不能重载？
堆污染的 ClassCastException 到底抛在哪里？
泛型数组到底怎么创建才是对的？
为什么 instanceof List<String> 编译不过？
静态字段/静态方法为什么不能用类的泛型参数？

1. 擦除之后，编译器在背后插了 checkcast

static String first(List<String> list) {
    return list.get(0);
}

擦除后 get 的签名是 Object get(int)，那这一行凭什么能编译通过？

javac AfterErasureDemo.java
javap -c -p AfterErasureDemo

  static java.lang.String first(java.util.List<java.lang.String>);
    Code:
       0: aload_0
       1: iconst_0
       2: invokeinterface #31,  2           // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
       7: checkcast     #37                 // class java/lang/String
      10: areturn

（常量池编号随文件内容变化，看 checkcast 那一行即可。）

答案在 checkcast：编译器在每个需要具体类型的位置自动插入类型检查指令。

所以泛型的类型安全是两层：

层	做什么	谁保证
编译期	检查你写的类型对不对	javac
运行期	在取值处插入 `checkcast` 兜底	编译器生成的字节码

这也解释了后面堆污染为什么"编译能过、运行才炸"——炸的就是这条 checkcast。

2. 桥方法：多态为什么还能成立

2.1 问题从哪来

class Node<T> {
    public T get() { return null; }
}

class StringNode extends Node<String> {
    @Override
    public String get() { return "s"; }
}

擦除后：

父类方法：Object get()
子类方法：String get()

这是两个签名不同的方法。那么 Node<String> n = new StringNode(); n.get(); 是怎么调到子类实现的？按方法表（vtable）找，父类那格存的是 get()Ljava/lang/Object;，而子类只提供了 get()Ljava/lang/String;，对不上，多态直接失效。

2.2 编译器的解法：合成桥方法

编译器在子类里额外生成一个方法，把调用转发给真正的方法：

class StringNode extends Node<String> {
    public String get() { return "s"; }

    // 编译器合成，源码里看不到，字节码里真实存在
    // public Object get() { return this.get(); }
}

验证：

javap -c -p StringNode

class StringNode extends Node<java.lang.String> {
  public java.lang.String get();
    Code:
       0: ldc           #7                  // String s
       2: areturn

  public java.lang.Object get();
    Code:
       0: aload_0
       1: invokevirtual #9                  // Method get:()Ljava/lang/String;
       4: areturn
}

上面第二个 get()——参数是 Object、返回 Object 的那个——就是编译器合成的桥方法。

javap 默认不显示 ACC_BRIDGE 标志，加 -v 能看到 flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC。

2.3 怎么在代码里识别

for (Method m : StringNode.class.getDeclaredMethods()) {
    System.out.println(m + " bridge=" + m.isBridge() + " synthetic=" + m.isSynthetic());
}

public java.lang.String StringNode.get() bridge=false synthetic=false
public java.lang.Object StringNode.get() bridge=true synthetic=true

实用结论：

反射遍历方法时会多出一个桥方法，统计"类有几个方法"时别被它骗了。
getMethod("get") / getDeclaredMethod("get") 在桥方法存在时行为容易踩坑，框架里普遍用 Method.isBridge() 过滤，Spring 还有专门的 BridgeMethodResolver 来从桥方法找回原始方法。
桥方法不是泛型独有的：协变返回类型（Object clone() → Person clone()）同样会生成桥方法。

3. 重载冲突：擦除后签名撞车

void m(List<String> a) {}
void m(List<Integer> b) {}

编译错误：

name clash: m(java.util.List<java.lang.Integer>) in Demo and
m(java.util.List<java.lang.String>) in Demo have the same erasure

重载的判定依据是擦除后的签名（方法名 + 参数类型的擦除结果），上面两个擦除后都是 m(List)，所以不构成重载，而是重复定义。

对比着记：

void m(List<String> a) {}
void m(Collection<String> b) {}   // 合法：擦除后是 List 和 Collection，不同

想表达"同一件事、不同泛型参数"时，只能：

换方法名（mList / mSet）；
换参数容器（List vs Set）；
换参数个数或位置，把泛型参数挤到别的地方去。

这也是为什么很多 API 里会出现 of / ofList 这种看起来多余的命名——不是作者懒，是签名撞了。

4. 堆污染：异常抛在"读"的地方，不是"写"的地方

01 里只说了"堆污染"这个词，这里做完整实验。

4.1 最小复现

static void testHeapPollution() {
    List<String> strings = new ArrayList<>();

    List raw = strings;        // 原始类型，绕开编译期检查
    raw.add(123);              // ① 写入成功，这里不报错

    String s = strings.get(0); // ② ClassCastException 在这里抛
    System.out.println(s);
}

Exception in thread "main" java.lang.ClassCastException:
    class java.lang.Integer cannot be cast to class java.lang.String

关键点：污染发生在 ①，但异常抛在 ②。因为 add 的擦除签名是 add(Object)，放什么进去 JVM 都不管；真正做类型检查的是编译器插在 get 之后的那条 checkcast（见 §1）。

所以 -Xlint:unchecked 警告不要关：

javac -Xlint:unchecked AfterErasureDemo.java

AfterErasureDemo.java:43: 警告: [unchecked] 对作为原始类型List的成员的add(E)的调用未经过检查
        raw.add(123);                  // ① 成功，这里不报错

（第 8 节的完整代码不再用 @SuppressWarnings 把警告压掉，所以读者照抄命令就能看到同一条警告；示例里只把 broken(T...) 那条 vararg 警告留在第 8 节说明。）

4.2 换个马甲：方法参数传原始类型

static void fill(List<String> list) {
    ((List) list).add(123);   // 编译警告，但编译通过
}

调用方完全看不出 fill 会往 List<String> 里塞 Integer，坑就是这么埋下的。

4.3 可变参数与 `@SafeVarargs` 的边界

// 安全：只读这个数组
@SafeVarargs
static <T> List<T> listOf(T... items) {
    return new ArrayList<>(Arrays.asList(items));   // 转发给另一个 @SafeVarargs 方法，不写入
}

// 不安全：往数组里写了 "不是 T" 的东西
static <T> void broken(T... items) {
    Object[] raw = items;        // 合法：数组协变
    raw[0] = new Object();       // 调用点传 String 字面量时，这里 ArrayStoreException
}

broken("a", "b");                // 调用点创建的是 String[]，不是 Object[]

T... 底层是数组，而且这个数组是调用点创建的，运行时类型由调用点推断：传 String 字面量得到 String[]。

所以 @SafeVarargs 不是编译器的验证结论，而是一个承诺：

能加：方法只读这个数组（转发给 Arrays.asList、List.of 这类）。
不能加：方法往数组里写、或者把数组交给别人去写。

编译器不会替你检查这个承诺——写了，运行时照样炸。

使用限制：只能标注在 static、final、private（JDK 9+）方法或构造器上，因为否则子类可以重写并破坏承诺。

5. 泛型数组：正确写法与它为什么带警告

5.1 直接 `new T[]` 不行，`(T[]) new Object[n]` 是骗自己

T[] a = new T[10];                   // 编译错误：generic array creation

T[] b = (T[]) new Object[10];        // 编译警告，运行时元素类型还是 Object

第二种的运行时类型是 Object[]。你把它当 String[] 用，一旦有人往里放别的类型，异常还是抛在读取处：

Integer[] ints = (Integer[]) new Object[]{"a", "b"};   // 读的时候就炸

5.2 唯一正确的方式：显式传 Class

import java.lang.reflect.Array;

@SuppressWarnings("unchecked")
static <T> T[] newArray(Class<T> type, int n) {
    return (T[]) Array.newInstance(type, n);
}

String[] a = newArray(String.class, 3);
System.out.println(a.getClass());   // class [Ljava.lang.String;

为什么这条是安全的：Array.newInstance(type, n) 出来的数组元素类型真的是 T，不存在堆污染，只是编译器不知道，所以需要一个 @SuppressWarnings("unchecked")。

这也解释了框架里那些"莫名其妙"的签名——为什么 TypeHandler、Converter、BaseMapper 都要你把 Class<T> 传进去：运行时唯一的类型来源就是你显式给的那个 Class 对象。

5.3 集合转数组的惯用法

List<String> list = new ArrayList<>();
String[] a1 = list.toArray(new String[0]);        // 老写法
String[] a2 = list.toArray(String[]::new);        // JDK 11+，等价且更清晰

toArray(T[]) 的泛型参数在这里的作用是"借你用一下元素类型"，JDK 内部也是走反射创建数组。传 new String[0] 不会白创建——JDK 会检查数组长度不够就另建一个，够用就直接用。

6. 为什么不能 `instanceof List<String>`

Object o = new ArrayList<>();
if (o instanceof List<String>) { }   // 编译错误：illegal generic type for instanceof

原因很直接：运行时 ArrayList<String> 和 ArrayList<Integer> 是同一个类，这个判断没有可判定的运行时语义。编译器宁可报错也不让你写出一个永远为真（或永远为假）的条件。

能写的是无界通配符：

if (o instanceof List<?>) { }        // 合法：只判断"是不是 List"

如果真需要拿到泛型实参，只能回到声明处，用反射（01 §7 讲过）：

Field f = Demo.class.getDeclaredField("names");
Type t = f.getGenericType();
if (t instanceof ParameterizedType pt) {
    Type arg = pt.getActualTypeArguments()[0];
    System.out.println(arg);   // class java.lang.String
}

注意这读的是字段声明，不是实例。而且如果声明写的是 List<T>，这里拿到的是 TypeVariable（T），不是具体类——这也是 Spring ResolvableType 存在的原因：它得沿着父类、接口一层层把 T 解出来。

7. 静态成员为什么不能用类的泛型参数

class Box<T> {
    static T value;                  // 编译错误
    static T get() { return null; }  // 编译错误
}

error: non-static type variable T cannot be referenced from a static context

三条理由：

静态成员属于类，不属于实例。T 是在"你拿到一个 Box<String> 引用"时才有意义的，静态上下文里没有这个信息。
擦除后每个类只有一份静态区。如果允许，Box<String>.value 和 Box<Integer>.value 会是同一块内存，类型根本没法保证。
static 方法不能调用实例的泛型参数，因为它在类初始化阶段就可能被调用，此时连实例都没有。

正确写法：静态方法自己声明类型参数。

class Box {
    static <T> T get(Class<T> type) { return null; }   // T 是方法自己的，与任何实例无关
}

class Box2<T> {
    static <U> U pick(U a, U b) { return a; }          // U 与方法绑定
}

区分清楚：<T> 写在类上叫类泛型参数，写在方法上叫方法泛型参数。静态方法想要泛型，只能走后者。

8. 完整验证代码

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class AfterErasureDemo {

    public static void main(String[] args) {
        testCheckcast();
        testBridge();
        testHeapPollution();
        testVarargs();
        testArray();
        testInstanceof(new ArrayList<String>());
    }

    // 1) checkcast：用 javap -c -p 看字节码
    static String first(List<String> list) {
        return list.get(0);   // 编译后，get 指令后面跟着一条 checkcast java/lang/String
    }

    static void testCheckcast() {
        System.out.println(first(Arrays.asList("a", "b")));
    }

    // 2) 桥方法
    static void testBridge() {
        Node<String> n = new StringNode();
        System.out.println(n.get());   // s——靠桥方法维持多态

        // getDeclaredMethods 的顺序不保证，看内容即可
        for (Method m : StringNode.class.getDeclaredMethods()) {
            System.out.println(m + " bridge=" + m.isBridge() + " synthetic=" + m.isSynthetic());
        }
    }

    // 3) 堆污染：写入不报错，读取才炸
    static void testHeapPollution() {
        List<String> strings = new ArrayList<>();

        List raw = strings;
        raw.add(123);                  // ① 成功，这里不报错

        try {
            String s = strings.get(0); // ② 异常在这里抛
            System.out.println(s);
        } catch (ClassCastException e) {
            System.out.println("读的时候才炸: " + e.getMessage());
        }
    }

    // 4) 可变参数：数组由调用点创建
    @SafeVarargs
    static <T> List<T> listOf(T... items) {
        return new ArrayList<>(Arrays.asList(items));   // 只读，安全
    }

    static <T> void broken(T... items) {
        Object[] raw = items;          // 合法：数组协变
        raw[0] = new Object();         // 调用点传 String 字面量时 → ArrayStoreException
    }

    static void testVarargs() {
        System.out.println(listOf("a", "b"));
        try {
            broken("a", "b");
        } catch (ArrayStoreException e) {
            System.out.println("变参数组被写脏: " + e.getMessage());
        }
    }

    // 5) 泛型数组：显式传 Class
    @SuppressWarnings("unchecked")
    static <T> T[] newArray(Class<T> type, int n) {
        return (T[]) Array.newInstance(type, n);
    }

    static void testArray() {
        String[] a = newArray(String.class, 2);
        a[0] = "x";
        System.out.println(a.getClass() + " " + a[0]);   // class [Ljava.lang.String; x
    }

    // 6) instanceof：只能无界通配符
    static void testInstanceof(Object o) {
        System.out.println(o instanceof List<?>);   // true
        // o instanceof List<String>   // 编译错误：illegal generic type for instanceof
    }
}

// 桥方法用到的两个类：放成顶层类，javap StringNode 的输出才干净
class Node<T> {
    public T get() { return null; }
}

class StringNode extends Node<String> {
    @Override
    public String get() { return "s"; }
}

参考输出：

a
s
public java.lang.String StringNode.get() bridge=false synthetic=false
public java.lang.Object StringNode.get() bridge=true synthetic=true
读的时候才炸: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
[a, b]
变参数组被写脏: java.lang.Object
class [Ljava.lang.String; x
true

编译期一共两条 unchecked 警告，都在声明/调用点而不是运行点：一条在 raw.add(123)（原始类型 List 的 add），一条在 broken(T...) 的声明处——“参数化 vararg 类型 T 的堆可能已受污染”。只读的 listOf(T...) 不报，这是编译器对可变参数泛型能给出的唯一提示。（上面第 3 行 ClassCastException 的完整信息在 JDK 9+ 会附带 module/loader 说明，不同版本尾注略有差异。）

再补两条命令：

javap -c -p AfterErasureDemo | grep -A2 checkcast   # 看编译器插的类型检查
javap -v StringNode | grep -A3 ACC_BRIDGE          # 看桥方法的标志位（输出 flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC）

9. 面试问法

Q1：擦除之后 list.get(0) 凭什么能直接赋给 String？

编译器在取值处自动插入了 checkcast 指令。泛型的类型安全是两层：编译期由 javac 检查你写的类型，运行期由编译器生成的 checkcast 兜底。堆污染的异常就是抛在这条指令上。

Q2：桥方法是什么？为什么需要它？

子类重写泛型方法后，擦除让父类方法签名变成 Object get()、子类方法是 String get()，两者签名不一致。为了让父类引用调用时仍能命中子类实现，编译器在子类合成一个 Object get() 的桥方法，把调用转发给 String get()。识别方式：Method.isBridge() / isSynthetic()；协变返回类型的重写也会生成桥方法。

Q3：为什么两个只差泛型参数的方法不能重载？

重载的判定依据是擦除后的签名。m(List<String>) 和 m(List<Integer>) 擦除后都是 m(List)，编译器报 name clash ... have the same erasure。只能换方法名，或者换参数容器（List / Collection）。

Q4：堆污染是什么？为什么异常不在写入时抛？

往"名义上有泛型、实际擦除了"的容器里塞进类型不符的元素。写入时 add 的擦除签名是 add(Object)，JVM 不检查；真正检查的是编译器插在读取处赋值点的 checkcast，所以异常抛在 String s = list.get(0) 那一行。这也是 -Xlint:unchecked 警告不能关的原因。

Q5：泛型数组怎么创建才是对的？

Array.newInstance(clazz, n) 并显式传入 Class<T>，因为运行时唯一的类型来源就是 Class 对象。(T[]) new Object[n] 只是把问题推迟成堆污染。集合转数组用 list.toArray(new T[0]) 或 JDK 11+ 的 list.toArray(T[]::new)。

Q6：为什么不能 instanceof List<String>？

运行时 List<String> 和 List<Integer> 是同一个类，这个判断没有可判定的运行时语义，编译器直接报 illegal generic type for instanceof。只能写 instanceof List<?>；想拿泛型实参必须回到字段/方法/父类的声明处用反射读 getGenericType()，而且声明若是 List<T>，拿到的还是 TypeVariable。

Q7：静态方法为什么不能用类的泛型参数？

静态成员属于类而不是实例，T 只在拿到具体实例（Box<String>）时才有意义；擦除后每个类只有一份静态区，Box<String>.value 和 Box<Integer>.value 会是同一块内存。静态方法要泛型，必须自己声明方法级类型参数：static <T> T get(Class<T> type)。

10. 小结

擦除之后，所有类型安全靠两个机制补：编译期检查 + 编译器插入的 checkcast。
桥方法（ACC_BRIDGE）是"擦除后多态仍然成立"的代价；反射里要记得过滤桥方法。
重载看擦除后的签名，泛型参数不同不算重载。
堆污染的异常抛在读取处，写入处静默通过。
泛型数组只能 Array.newInstance(clazz, n)；@SafeVarargs 是承诺，不是验证。
instanceof 不能带泛型实参，只能 List<?>。
静态成员不能用类泛型参数，静态泛型方法要自己声明 <T>。

记忆钩子："能擦的都擦了，擦不掉的靠 checkcast 和桥方法兜住。"

11. 下一步

[ ] 手跑第 8 节代码，对照参考输出。
[ ] javap -c -p 找 checkcast，javap -v 找 ACC_BRIDGE。
[ ] 闭卷复述第 9 节 7 个问题。
[ ] 写下一篇：03-通配符与PECS（? extends / ? super、PECS 原则、通配符捕获、Comparable<? super T> 为什么长这样）。

通配符与 PECS：? extends 与 ? super 到底在限制谁

akm — Tue, 15 Sep 2026 00:00:00 GMT

所属：Java 面试笔记 / 01-Java基础 / 01-泛型｜学习计划：D1 前置：02-擦除之后｜后续：04-泛型在框架中的应用（待写）

0. 本文要解决什么

前两篇讲的是运行期：泛型被擦除了，于是有桥方法、checkcast、堆污染。

这一篇换个角度，只看编译期：既然擦除后大家都是 List，javac 凭什么还能在编译期把类型错误拦住？靠的就是通配符这套"方向性"规则。

要回答的问题：

为什么 List<String> 能赋给 List<?>，却不能赋给 List<Object>？
List<? extends Number> 为什么"能读不能写"？到底是谁在禁止 add？
List<? super Integer> 为什么"能写不能读"？读出来为什么只能是 Object？
PECS 是什么？看到一个方法签名怎么判断方向写得对不对？
编译错误里的 CAP#1（capture）是什么？
swap(List<?>, int, int) 为什么编译不过，JDK 自己怎么绕过去？
Comparable<? super T> 里的 ? super 到底解决了什么问题？
泛型方法什么时候该写 <T>、什么时候只用通配符？

运行环境：JDK 17（Temurin 17.0.16）。下面所有报错和输出都是真跑出来的，JDK 源码摘自 lib/src.zip。

1. 泛型是不变的（invariant）

1.1 一个编译不过的赋值

List<Object> list = new ArrayList<String>();   // 想当然的写法

javac BadInvariant.java

BadInvariant.java:4: 错误: 不兼容的类型: ArrayList<String>无法转换为List<Object>
        List<Object> list = new ArrayList<String>();
                            ^
1 个错误

直觉上 String 是 Object 的子类，List<String> 就该是 List<Object> 的子类。Java 偏偏不允许——这不叫"没实现"，叫不变性（invariance）：List<A> 与 List<B> 之间，除了通配符，没有任何继承关系。

1.2 为什么必须这样设计：数组的教训

数组是协变的，Java 允许这样写，于是留下一个运行期漏洞：

Object[] arr = new String[3];    // 编译通过
arr[0] = 1;                      // 编译通过！类型错误被推迟到运行期

运行期: java.lang.ArrayStoreException: java.lang.Integer

arr 的静态类型是 Object[]，看起来什么都能放；但它的运行期类型是 String[]，JVM 直到执行 aastore 才发现类型不对。数组的协变等于把类型检查推迟到了运行期。

如果 List<Object> list = new ArrayList<String>() 合法，同样的漏洞会出现，而且更糟——擦除之后连"运行期类型"都没得查：

List<Object> list = new ArrayList<String>();   // 假设合法
list.add(1);                                   // 编译期看是 List<Object>，合法
String s = list.get(0);                        // 运行期 checkcast：Integer -> String，炸

所以泛型选了不变：编译期能拒绝的错误，绝不留到运行期。

1.3 四条赋值规则（先记方向）

声明	能接受哪些实参	说明
`List<Object> a`	只有 `List<Object>`	不变，最严格
`List<?> b`	任何 `List<X>`	无界通配符，所有 `List` 的父类型
`List<? extends Number> c`	`List<Number>`、`List<Integer>`、`List<Double>`…	上界通配符，向下兼容所有子类型
`List<? super Integer> d`	`List<Integer>`、`List<Number>`、`List<Object>`	下界通配符，向上兼容所有父类型

实测：

List<?> anything = new ArrayList<String>();                  // 可以
List<? extends Number> producer = new ArrayList<Integer>();  // 可以
producer = new ArrayList<Double>();                          // 换个子类型也行
producer = new ArrayList<Number>();                          // 上界本身也行
List<? super Integer> consumer = new ArrayList<Integer>();
consumer = new ArrayList<Number>();
consumer = new ArrayList<Object>();

一句话：通配符是用来"放宽接收范围"的，方向由 extends / super 决定。

2. `? extends`：只读的生产者

2.1 能读到什么

List<? extends Number> list = new ArrayList<Integer>();
Number n = list.get(0);      // 编译通过，静态类型是上界 Number

get 的静态返回类型是 ? extends Number 捕获后的类型，编译器统一读成上界 Number：不管实际是 Integer 还是 Double，都是 Number 的子类型，读出来安全。

2.2 为什么不能写

list.add(1);       // 编译不过
list.add(1.0);     // 编译不过
list.add(null);    // 唯一合法的写入

javac BadExtends.java

BadExtends.java:6: 错误: 不兼容的类型: int无法转换为CAP#1
        list.add(1);                         // 写：编译不过
                 ^
  其中, CAP#1是新类型变量:
    CAP#1从? extends Number的捕获扩展Number
BadExtends.java:7: 错误: 不兼容的类型: double无法转换为CAP#1
（第 7 行 list.add(1.0) 报同样的错，略）
2 个错误

关键点：报错的主体不是 Number，而是 CAP#1。

list 声明成 List<? extends Number> 时，真实元素类型对调用方是未知的——可能是 Integer，也可能是 Double。编译器用一个内部符号 CAP#1 表示"某个具体的、但此处不知道是谁的 Number 子类型"，而 add 的形参就是这个 CAP#1。既然不知道它是谁，任何具体值都塞不进去：

塞 Integer：万一是 List<Double>，就堆污染了；
塞 Double：万一是 List<Integer>，同样堆污染；
塞 null：null 是所有引用类型的值，与具体类型无关，唯一安全。

所以"上界通配符只能读、不能写"的准确含义是：不是限制你，是编译器真的不知道往哪个类型里写。

2.3 和数组协变对照

	数组	泛型 + `? extends`
语法	`Number[] a = new Integer[2];`	`List<? extends Number> l = new ArrayList<Integer>();`
是否协变	是	是
写	`a[0] = 1.5;` 编译通过，运行期 `ArrayStoreException`	`l.add(1.5)` 编译期直接拒绝
读	`Number n = a[0];`	`Number n = l.get(0);`

同一个协变想法，数组靠运行期兜底，泛型靠编译期拦下——区别就是泛型把"写的时候不能做什么"记录进了类型。

3. `? super`：只写的消费者

3.1 能写什么

List<? super Integer> list = new ArrayList<Number>();
list.add(1);                          // 编译通过
list.add(Integer.valueOf(2));         // 编译通过

? super Integer 表示"某个 Integer 的父类型"：可能是 Integer、Number、Object。不管具体是哪个，Integer 一定是它的子类型，所以写入 Integer 永远合法。

3.2 为什么读出来只能是 `Object`

Object o = list.get(0);      // 可以
Integer i = list.get(0);     // 编译不过

javac BadSuper.java

BadSuper.java:5: 错误: 不兼容的类型: CAP#1无法转换为Integer
        Integer i = list.get(0);             // 读：编译不过，只能当 Object
                            ^
  其中, CAP#1是新类型变量:
    CAP#1从? super Integer的捕获扩展Object 超 Integer
1 个错误

注意报错里的描述：CAP#1 扩展 Object 超 Integer。? super Integer 的上界是 Object（Integer 只是下界），所以取值只能保证是 Object。想拿到具体类型，只能强转，或者改用泛型方法（见第 5 节）。

3.3 对照表

	`List<? extends Number>`	`List<? super Integer>`
实际可能是	`List<Number>`、`List<Integer>`、`List<Double>`	`List<Integer>`、`List<Number>`、`List<Object>`
`get(0)`	`Number` ✓	`Object` ✓
`add(1)`	✗ CAP#1	✓
`add(1.0)`	✗ CAP#1	✗（`Double` 不是 `Integer` 的子类型）
`add(null)`	✓	✓
角色	生产者（只读）	消费者（只写）

4. PECS：Producer Extends, Consumer Super

4.1 规则

参数是"生产者"（方法从它读数据）→ 用 ? extends T；参数是"消费者"（方法往它写数据）→ 用 ? super T。

判断只有一句话：站在方法体里看，这个集合是被读还是被写？

被读 → extends
被写 → super
既读又写 → 不能用通配符，改用方法级类型参数 <T>（第 5 节）

4.2 自己写三个签名

/** 只读：生产者用 extends */
static double sum(List<? extends Number> src) { ... }

/** 只写：消费者用 super */
static void fill(List<? super Integer> dest, int n) { ... }

/** 一读一写：src 是生产者、dest 是消费者，各用各的 */
static <T> void copy(List<? super T> dest, List<? extends T> src) { ... }

$ java PecsDemo
sum(List<Integer>) = 6.0
sum(List<Double>)  = 4.0
sum(List.of(1, 2L, 3.0f, 4.0)) = 10.0
fill -> [0, 1, 2]
copy -> [a, b]
before sort: [3, 1, 2]
after sort:  [3, 2, 1]
copied:      [3, 2, 1]

sum 一行通吃 List<Integer> / List<Double> / 混合数字列表；写成 sum(List<Number>) 就没有这个能力（List<Integer> 不是 List<Number>，回到第 1 节的不变性）。

copy 是最能说明 PECS 的例子：dest 用 super、src 用 extends，一次同时用上两条规则，而且调用方不需要指定 T——编译器从两个实参推断出 T = String。

4.3 JDK 里到处都是 PECS

用反射把 JDK 的真实签名打出来（JdkSignatures.java）：

Collection.addAll  boolean addAll(java.util.Collection<? extends E>)
List.sort          void sort(java.util.Comparator<? super E>)
Collections.copy   <T extends java.lang.Object> void copy(java.util.List<? super T>, java.util.List<? extends T>)
Collections.fill   <T extends java.lang.Object> void fill(java.util.List<? super T>, T)
Collections.max    <T extends java.lang.Object extends java.lang.Comparable<? super T>> T max(java.util.Collection<? extends T>)
Collections.sort   <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T>)
Collections.addAll <T extends java.lang.Object> boolean addAll(java.util.Collection<? super T>, T[])
Stream.forEach     void forEach(java.util.function.Consumer<? super T>)
Stream.map         <R extends java.lang.Object> java.util.stream.Stream<R> map(java.util.function.Function<? super T, ? extends R>)

翻译成人话：

JDK API	为什么是这个方向
`Collection.addAll(Collection<? extends E> c)`	参数是元素来源（生产者）→ `extends`
`Collections.addAll(Collection<? super T> c, T... elements)`	参数是被填充的目标（消费者）→ `super`
`Collections.copy(List<? super T> dest, List<? extends T> src)`	教科书式的一读一写
`Collections.fill(List<? super T> list, T obj)`	只写 → `super`
`List.sort(Comparator<? super E> c)`	比较器消费集合元素 → `super`
`Stream.forEach(Consumer<? super T> action)`	同上，动作消费元素 → `super`
`Stream.map(Function<? super T, ? extends R> mapper)`	入参消费 `super T`、出参生产 `extends R`
`Collections.max(Collection<? extends T>)`	只读（生产者）→ `extends`，返回值就是 `T`

记法：看到 ? extends 就知道它在读，看到 ? super 就知道它在写。

顺带解释一个老问题：为什么 Stream.map 的参数里同时出现 ? super T 和 ? extends R？因为一个 Function 既消费又生产——入参是消费者，出参是生产者，一个参数位就要写两条规则。

Collections.copy 的源码最能说明问题（JDK 17，java.base/java/util/Collections.java）：

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");

    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i=0; i<srcSize; i++)
            dest.set(i, src.get(i));        // ← T 从 src 来、进 dest 去，两个方向都对得上
    } else { ... }
}

src.get(i) 静态类型是 ? extends T（是 T），dest.set(i, T) 要求 ? super T（能接 T）。PECS 的本质就是让这一行能编译。另外注意 dest 必须预先有足够长度，否则抛 IndexOutOfBoundsException——这也是它和 addAll 的分工差别。

4.4 方向写反了会怎样

static void sum(List<Number> src)                                    // 太窄：List<Integer> 传不进来
static <T> void copy(List<? extends T> dest, List<? super T> src)    // 方向反了

第二种会在方法体里报错：dest 的 add/set 形参是 CAP#2，src 的元素是 CAP#1，编译器无法证明两者相同。所以有个好用自检法：方法体能编译过，就说明签名方向写对了。

5. 通配符捕获：`CAP#1` 与 `<T>` 辅助方法

5.1 一个"看起来显然"却编译不过的 swap

static void swap(List<?> list, int i, int j) {
    list.set(i, list.get(j));      // 想让 i 位置存原来 j 位置的值
}

javac BadCapture.java

BadCapture.java:4: 错误: 不兼容的类型: Object无法转换为CAP#1
        list.set(i, list.get(j));
                            ^
  其中, CAP#1是新类型变量:
    CAP#1从?的捕获扩展Object
1 个错误

get 返回 Object，而 set 要的是 CAP#1（List<?> 里那个未知的元素类型）。编译器无法证明"取出来的东西"和"塞进去的位置"是同一个类型，于是拒绝。

5.2 两种解法：`<T>` 辅助方法 vs 原始类型

解法一：私有辅助方法把捕获类型"命名"下来（Effective Java 第 31 条的写法）

static void swap(List<?> list, int i, int j) {
    swapHelper(list, i, j);            // 对外保持最宽松的签名
}

private static <T> void swapHelper(List<T> list, int i, int j) {
    T tmp = list.get(i);               // 类型被命名成 T，get/set 就对上了
    list.set(i, list.get(j));
    list.set(j, tmp);
}

解法二：JDK 自己用的是原始类型（java.base/java/util/Collections.java）

@SuppressWarnings({"rawtypes", "unchecked"})
public static void swap(List<?> list, int i, int j) {
    // instead of using a raw type here, it's possible to capture
    // the wildcard but it will require a call to a supplementary
    // private method
    final List l = list;
    l.set(i, l.set(j, l.get(i)));
}

JDK 的注释把这个取舍写得很清楚：通配符是可以捕获的，但代价是加一个辅助方法；标准库为了少一个方法、多一个 @SuppressWarnings，选了原始类型。（l.set(j, l.get(i)) 还能把返回值当"原来 j 位置的值"用，顺手完成交换。）

两种解法都对，面试时能把取舍讲出来就是加分项：

解法	优点	代价
`<T>` 辅助方法	全程类型安全，无 `@SuppressWarnings`	多一个私有方法
原始类型 `List`	代码短	关掉类型检查，必须自己保证安全

$ java CaptureDemo
swap -> [3, 2, 1]
size=3, get(0)=3, class=Integer
after remove(0): [2, 1]
after clear(): []

捕获的本质是"编译器在调用点推断出一个具体类型"，而 <T> 让这个推断结果能被写出来、被复用。

5.3 `List<?>` 到底能干什么

List<?> unknown = ints;
unknown.size();          // ✓
unknown.get(0);          // ✓ 结果是 Object
unknown.remove(0);       // ✓ 调的是 remove(int index)，与元素类型无关
unknown.clear();         // ✓
unknown.add(null);       // ✓ 只有 null
unknown.add(1);          // ✗ 编译不过

所以 List<?> 的语义是："我不关心元素类型，也绝不往里放东西"——常出现在只用 size、判空、遍历打印的 API 上。

5.4 `List<Object>`、`List<?>`、`List<? extends Object>`

static void a(List<?> list) { }
static void a(List<? extends Object> list) { }   // 与方法一冲突

BadOnes.java:5: 错误: 已在类 BadOnes中定义了方法 a(List<?>)
        static void a(List<? extends Object> list) { }      // ① 通配符没带来任何区别：签名冲突

<?> 与 <? extends Object> 是同一个类型，重载直接冲突——写 ? extends Object 没有任何额外表达力，多写只是噪音。

类型	能 add 什么	能接受哪些实参	什么时候用
`List<Object>`	任何对象	只有 `List<Object>`	真的需要往同一个列表里放各种类型
`List<?>`	只能 `null`	所有 `List<X>`	只读：`size` / 判空 / 遍历
`List<? extends Object>`	同 `List<?>`	同 `List<?>`	别写，等价于 `List<?>`

5.5 什么时候用 `<T>`、什么时候用通配符

判据（Effective Java 第 31 条）：类型参数在方法签名的多个位置出现、需要把它们关联起来时用 <T>；只出现一个位置、只为放宽接收范围时用通配符。

场景	写法
参数只读，与返回值无关	`void print(List<?> list)`
参数只读，返回值跟元素类型挂钩	`<T> T first(List<? extends T> list)`
两个参数类型必须一致	`<T> void copy(List<? super T> dest, List<? extends T> src)`
参数既读又写	`<T> void sort(List<T> list)`

一个常被追问的点：static <T> void print(List<T> list) 也能编译，为什么不算好签名？ 因为 T 在方法体里没有任何用途，调用方却多了一层推断负担；语义上它和 print(List<?>) 完全等价。这种属于"为了泛型而泛型"，评审时应改回 List<?>。

6. `Comparable<? super T>`：`? super` 最经典的用法

6.1 先把问题摆出来

class Base implements Comparable<Base> { ... }
class Sub extends Base { }        // 自己没实现 Comparable，继承来的是 Comparable<Base>

写一个取最大值的泛型方法，先按直觉写：

static <T extends Comparable<T>> T max(List<? extends T> list) { ... }

Sub s = max(List.of(new Sub(3), new Sub(1)));   // 希望 T = Sub

javac BadComparable.java

BadComparable.java:20: 错误: 不兼容的类型: 推论变量 T 具有不兼容的上限
        Sub s = max(List.of(new Sub(3), new Sub(1)));   // 要求 T = Sub
                   ^
    等式约束条件：Base
    下限：Sub,Comparable<T>
  其中, T是类型变量:
    T扩展已在方法 <T>max(List<? extends T>)中声明的Comparable<T>
1 个错误

T extends Comparable<T> 要求"T 自己实现了 Comparable<T>"。Sub 只实现了 Comparable<Base>，不满足，推断失败。真实项目里最常见的触发场景是 java.sql.Timestamp：它 extends java.util.Date，而 Date implements Comparable<Date>，所以 Timestamp 并不实现 Comparable<Timestamp>。

6.2 把 `T` 放宽成"能比较 `T` 的类型"

static <T extends Comparable<? super T>> T max(List<? extends T> list) {
    T best = list.get(0);
    for (T t : list) if (t.compareTo(best) > 0) best = t;
    return best;
}

Sub s = max(List.of(new Sub(3), new Sub(1), new Sub(2)));   // 编译通过，返回类型就是 Sub

$ java ComparableDemo
max(Sub)     = Sub(3)  运行期类型=Sub
max(String)  = c
max(Integer) = 9

Comparable<? super T> 的意思是"T 的某个父类型实现了 Comparable"：

Sub → Comparable<Base> ✓（Base 是 Sub 的父类）
String → Comparable<String> ✓（T 自己也算 ? super T）
Integer → Comparable<Integer> ✓

换成 Comparable<T>，只有第二、三种能过。? super 在这里买到的是"允许沿继承链比较"，代价只是签名长一点。

6.3 JDK 的原始签名与那个 `Object &`

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();
    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) > 0)
            candidate = next;
    }
    return candidate;
}

Comparable<? super T>：逻辑需要，理由见 6.2。
Object &：擦除后 T extends Comparable<? super T> 的上界是 Comparable，返回类型会变成 Comparable；写上 Object & 之后上界变成 Object，才能与泛型时代之前 max(Collection) 的签名保持二进制兼容。这是给老字节码兜底的产物，不是逻辑需要。

被追问"这个 Object & 是干嘛的"，答"保持与擦除前签名的兼容"就够了。

6.4 记忆钩子

? super 出现在边界里，永远在说同一件事："我只需要一个能接受 T 的容器/比较器，不需要它精确等于 T。"

7. 嵌套通配符：外层不变、内层才放开

泛型不变性对嵌套同样成立，而且很容易踩：

List<List<? extends Number>> outer = new ArrayList<List<Integer>>();   // 编译不过！

javac MoreRules.java

MoreRules.java:21: 错误: 不兼容的类型: ArrayList<List<Integer>>无法转换为List<List<? extends Number>>
        List<List<? extends Number>> outer = new ArrayList<List<Integer>>();
                                             ^
1 个错误

因为 new ArrayList<List<Integer>>() 的类型是 ArrayList<List<Integer>>，外层实参是 List<Integer>，而要求的是 List<? extends Number>——外层没写通配符，就必须精确相等，List<Integer> 不等于 List<? extends Number>。

两种正确写法：

// 写法一：外层不放通配符 → 先建空表，再往里 add（元素类型正是 List<? extends Number>）
List<List<? extends Number>> outer = new ArrayList<>();
outer.add(new ArrayList<Integer>(List.of(1, 2)));

// 写法二：外层也放开 → 可以直接用子类型初始化
List<? extends List<? extends Number>> outer2 = new ArrayList<List<Integer>>();

outer -> [[1, 2]]
outer2 -> []

规则一句话：通配符只放宽它所在的那一层，不向下传递。

8. 完整验证代码

8.1 文件清单

gen03/
├── CovarianceDemo.java      # 数组协变 vs 泛型不变
├── PecsDemo.java            # sum / fill / copy + JDK 自带 API
├── CaptureDemo.java         # swap 的捕获辅助方法
├── ComparableDemo.java      # Comparable<? super T>
├── JdkSignatures.java       # 反射打印 JDK 真实签名
├── MoreRules.java           # 赋值规则、嵌套通配符
├── BadInvariant.java        # 故意编译失败：不变性
├── BadExtends.java          # 故意编译失败：? extends 不能写
├── BadSuper.java            # 故意编译失败：? super 只能读成 Object
├── BadCapture.java          # 故意编译失败：CAP#1
├── BadComparable.java       # 故意编译失败：Comparable<T> 太严
└── BadOnes.java             # 故意编译失败：4 个常见错误合集

javac CovarianceDemo.java PecsDemo.java CaptureDemo.java ComparableDemo.java JdkSignatures.java MoreRules.java
java  CovarianceDemo && java PecsDemo && java CaptureDemo && java ComparableDemo && java MoreRules && java JdkSignatures
javac BadInvariant.java BadExtends.java BadSuper.java BadCapture.java BadComparable.java BadOnes.java   # 看报错

8.2 CovarianceDemo.java

public class CovarianceDemo {
    public static void main(String[] args) {
        // 数组是协变的：编译通过，运行期才炸
        Object[] arr = new String[3];
        try {
            arr[0] = 1;                      // 把 Integer 塞进 String[]
        } catch (ArrayStoreException e) {
            System.out.println("运行期: " + e);
        }
        // 泛型是不变的：下面这行连编译都过不了（见 BadInvariant.java）
        // List<Object> list = new ArrayList<String>();
    }
}

运行期: java.lang.ArrayStoreException: java.lang.Integer

8.3 PecsDemo.java

import java.util.*;

public class PecsDemo {
    /** 只读：生产者用 extends */
    static double sum(List<? extends Number> src) {
        double s = 0;
        for (Number n : src) s += n.doubleValue();
        return s;
    }

    /** 只写：消费者用 super */
    static void fill(List<? super Integer> dest, int n) {
        for (int i = 0; i < n; i++) dest.add(i);
    }

    /** 一读一写：src 是生产者、dest 是消费者，各用各的 */
    static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (T t : src) dest.add(t);
    }

    public static void main(String[] args) {
        System.out.println("sum(List<Integer>) = " + sum(List.of(1, 2, 3)));
        System.out.println("sum(List<Double>)  = " + sum(List.of(1.5, 2.5)));
        System.out.println("sum(List.of(1, 2L, 3.0f, 4.0)) = " + sum(List.of(1, 2L, 3.0f, 4.0)));

        List<Number> numbers = new ArrayList<>();
        fill(numbers, 3);                    // List<Number> 是 List<? super Integer>
        System.out.println("fill -> " + numbers);

        List<Object> objects = new ArrayList<>();
        copy(objects, List.of("a", "b"));    // List<Object> dest + List<String> src
        System.out.println("copy -> " + objects);

        // JDK 自带的同一原则：
        List<Integer> ints = new ArrayList<>();
        Collections.addAll(ints, 3, 1, 2);   // addAll(Collection<? extends E>)
        System.out.println("before sort: " + ints);
        ints.sort(Comparator.reverseOrder()); // sort(Comparator<? super E>)
        System.out.println("after sort:  " + ints);
        List<Integer> copyTarget = Arrays.asList(new Integer[3]);
        Collections.copy(copyTarget, ints);  // copy(List<? super T>, List<? extends T>)
        System.out.println("copied:      " + copyTarget);
    }
}

sum(List<Integer>) = 6.0
sum(List<Double>)  = 4.0
sum(List.of(1, 2L, 3.0f, 4.0)) = 10.0
fill -> [0, 1, 2]
copy -> [a, b]
before sort: [3, 1, 2]
after sort:  [3, 2, 1]
copied:      [3, 2, 1]

8.4 CaptureDemo.java

import java.util.*;

public class CaptureDemo {
    /** 对外保持最宽松的签名 */
    static void swap(List<?> list, int i, int j) {
        swapHelper(list, i, j);
    }

    /** 私有辅助方法用 <T> 把这个 capture 命名下来 */
    private static <T> void swapHelper(List<T> list, int i, int j) {
        T tmp = list.get(i);
        list.set(i, list.get(j));
        list.set(j, tmp);
    }

    public static void main(String[] args) {
        List<Integer> ints = new ArrayList<>(List.of(1, 2, 3));
        swap(ints, 0, 2);
        System.out.println("swap -> " + ints);

        List<?> unknown = ints;
        System.out.println("size=" + unknown.size() + ", get(0)=" + unknown.get(0)
                + ", class=" + unknown.get(0).getClass().getSimpleName());
        unknown.remove(0);
        System.out.println("after remove(0): " + unknown);
        unknown.clear();
        System.out.println("after clear(): " + unknown);
        // unknown.add(1);                   // 编译不过：捕获类型无法确定
    }
}

swap -> [3, 2, 1]
size=3, get(0)=3, class=Integer
after remove(0): [2, 1]
after clear(): []

8.5 ComparableDemo.java

import java.util.*;

public class ComparableDemo {
    static class Base implements Comparable<Base> {
        final int v;
        Base(int v) { this.v = v; }
        @Override public int compareTo(Base o) { return Integer.compare(v, o.v); }
        @Override public String toString() { return getClass().getSimpleName() + "(" + v + ")"; }
    }

    static class Sub extends Base {
        Sub(int v) { super(v); }
    }

    /** 子类自己没实现 Comparable<Sub>，只从父类继承了 Comparable<Base>，所以必须写 ? super T */
    static <T extends Comparable<? super T>> T max(List<? extends T> list) {
        T best = list.get(0);
        for (T t : list) if (t.compareTo(best) > 0) best = t;
        return best;
    }

    public static void main(String[] args) {
        Sub s = max(List.of(new Sub(3), new Sub(1), new Sub(2)));   // T = Sub，返回值就是 Sub，不用强转
        System.out.println("max(Sub)     = " + s + "  运行期类型=" + s.getClass().getSimpleName());
        System.out.println("max(String)  = " + max(List.of("b", "c", "a")));
        System.out.println("max(Integer) = " + max(List.of(5, 9, 7)));
    }
}

max(Sub)     = Sub(3)  运行期类型=Sub
max(String)  = c
max(Integer) = 9

8.6 JdkSignatures.java

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

public class JdkSignatures {
    static void show(Class<?> owner, String name, Class<?>... params) {
        try {
            Method m = owner.getMethod(name, params);
            StringBuilder sb = new StringBuilder();
            for (TypeVariable<Method> tv : m.getTypeParameters()) {
                sb.append("<").append(tv.getName());
                for (Type b : tv.getBounds()) sb.append(" extends ").append(b.getTypeName());
                sb.append("> ");
            }
            String ps = Stream.of(m.getGenericParameterTypes()).map(Type::getTypeName).reduce((a, b) -> a + ", " + b).orElse("");
            System.out.printf("%-34s %s%s %s(%s)%n", owner.getSimpleName() + "." + name, sb, m.getGenericReturnType().getTypeName(), name, ps);
        } catch (Exception e) {
            System.out.println("ERR " + name + ": " + e);
        }
    }

    public static void main(String[] args) {
        show(Collection.class, "addAll", Collection.class);
        show(List.class, "sort", Comparator.class);
        show(Collections.class, "copy", List.class, List.class);
        show(Collections.class, "fill", List.class, Object.class);
        show(Collections.class, "max", Collection.class);
        show(Collections.class, "sort", List.class);
        show(Collections.class, "addAll", Collection.class, Object[].class);
        show(Stream.class, "forEach", java.util.function.Consumer.class);
        show(Stream.class, "map", java.util.function.Function.class);
    }
}

8.7 MoreRules.java

import java.util.*;

public class MoreRules {
    public static void main(String[] args) {
        // 通配符是「父类型」的方向：? extends 让多个具体实参都能赋给同一个变量
        List<? extends Number> producer = new ArrayList<Integer>();
        System.out.println(producer.getClass().getSimpleName() + " -> " + producer.size());
        producer = new ArrayList<Double>();          // 换一个实现类也行
        producer = new ArrayList<Number>();          // 上界本身也行
        producer.add(null);                          // 唯一的合法写入
        System.out.println("add(null) 之后 size=" + producer.size());

        // ? super 同理
        List<? super Integer> consumer = new ArrayList<Integer>();
        consumer = new ArrayList<Number>();
        consumer = new ArrayList<Object>();
        consumer.add(42);
        System.out.println("consumer -> " + consumer);

        // 嵌套：外层不变，声明成 List<List<? extends Number>> 之后，只能先建空表再 add
        List<List<? extends Number>> outer = new ArrayList<>();
        outer.add(new ArrayList<Integer>(List.of(1, 2)));   // 元素类型正是 List<? extends Number>
        // 外层也放开，才能直接用 ArrayList<List<Integer>> 初始化
        List<? extends List<? extends Number>> outer2 = new ArrayList<List<Integer>>();
        System.out.println("outer -> " + outer);
        System.out.println("outer2 -> " + outer2);

        // List<Object> 与 List<?> 的区别
        List<Object> objects = new ArrayList<>();
        objects.add("随便放");                        // List<Object> 能写
        List<?> anything = objects;                  // 任何 List<X> 都能赋给它
        Object first = anything.get(0);              // 只能读成 Object
        System.out.println("anything.size=" + anything.size() + ", first=" + first);
        System.out.println("List<Object> 能 add，List<?> 只能读、remove、clear");

        // 数组协变 vs 泛型不变，放一起对比
        Number[] nums = new Integer[2];              // 数组：编译通过，运行期可能炸
        try { nums[0] = 1.5; } catch (ArrayStoreException e) { System.out.println("数组协变: " + e); }
        System.out.println("数组协变是编译期'允许'、运行期兜底；泛型是编译期直接拒绝");
    }
}

ArrayList -> 0
add(null) 之后 size=1
consumer -> [42]
outer -> [[1, 2]]
outer2 -> []
anything.size=1, first=随便放
List<Object> 能 add，List<?> 只能读、remove、clear
数组协变: java.lang.ArrayStoreException: java.lang.Double
数组协变是编译期'允许'、运行期兜底；泛型是编译期直接拒绝

8.8 故意编译失败的文件

import java.util.*;

public class BadOnes {
    static void a(List<?> list) { }
    static void a(List<? extends Object> list) { }      // ① 通配符没带来任何区别：签名冲突

    static void b(List<?> list) {
        list.add("x");                                  // ② 无界通配符不能写入（null 除外）
    }

    static Number c(List<? extends Number> list) {
        List<Number> copy = list;                       // ③ 通配符不能反向赋给具体实参
        return copy.get(0);
    }

    static void d() {
        List<Object> objects = new ArrayList<String>(); // ④ 泛型不变：List<String> 不是 List<Object>
    }
}

BadOnes.java:5: 错误: 已在类 BadOnes中定义了方法 a(List<?>)
BadOnes.java:8: 错误: 不兼容的类型: String无法转换为CAP#1
  其中, CAP#1是新类型变量:
    CAP#1从?的捕获扩展Object
BadOnes.java:12: 错误: 不兼容的类型: List<CAP#1>无法转换为List<Number>
  其中, CAP#1是新类型变量:
    CAP#1从? extends Number的捕获扩展Number
BadOnes.java:17: 错误: 不兼容的类型: ArrayList<String>无法转换为List<Object>
4 个错误

③ 那条尤其值得记：List<? extends Number> 只能读，想把它当 List<Number> 用是反向赋值，编译器连类型都不认。

9. 面试问法

Q1：为什么 List<String> 不能赋给 List<Object>？

泛型是不变的。如果允许，就会出现 List<Object> l = new ArrayList<String>(); l.add(1); 这种编译期合法、运行期 checkcast 爆炸的代码。数组是协变的，正好演示了这个后果——Object[] a = new String[3]; a[0] = 1; 编译通过、运行期 ArrayStoreException。泛型选择了"编译期就拒绝"，代价是需要通配符来表达协变/逆变。

Q2：List<? extends Number> l = new ArrayList<Integer>(); l.add(1); 为什么编译不过？

因为 ? extends Number 的实际元素类型对调用方未知，编译器用 CAP#1 表示"某个 Number 的子类型"，add 的形参就是这个 CAP#1。塞 Integer 万一是 List<Double> 就污染了，所以只有在类型确定时才允许写。读没问题，l.get(0) 静态类型是 Number；add(null) 也允许，因为 null 与具体类型无关。

Q3：List<? super Integer> 能写什么、能读成什么？

能写 Integer（以及它的子类），因为 ? super Integer 的每个可能取值（Integer/Number/Object）都能接受 Integer。读出来只能保证是 Object，因为上界是 Object；想要具体类型得强转或改用泛型方法。

Q4：PECS 是什么？怎么判断方向？

Producer Extends, Consumer Super：参数是数据来源（被读）用 ? extends T，参数是数据去向（被写）用 ? super T。站在方法体里看"这个集合是被读还是被写"即可。JDK 里例子很多：Collections.copy(List<? super T> dest, List<? extends T> src)、List.sort(Comparator<? super E>)、Stream.map(Function<? super T, ? extends R>)（一个参数位既消费又生产，所以两条规则同时出现）。签名方向写反，方法体编译不过——这也是自检手段。

Q5：编译错误里的 CAP#1 是什么？

通配符捕获（capture conversion）。编译器把 ? 或 ? extends X 换成一个内部的、调用点唯一的类型变量。List<?> l; l.set(i, l.get(j)) 报 Object无法转换为CAP#1 就是它：get 给的是 Object，set 要的是那个未知的 CAP#1。解法是用 <T> 辅助方法把这个类型命名下来，或者像 Collections.swap 那样用原始类型 + @SuppressWarnings。

Q6：Collections.swap(List<?>, int, int) 是怎么实现的？

JDK 17 用的是原始类型：final List l = list; l.set(i, l.set(j, l.get(i)));，并加 @SuppressWarnings({"rawtypes","unchecked"})。源码注释写得很直白："通配符是可以捕获的，但那需要额外的私有辅助方法"——所以标准库选了原始类型这条捷径。自己写代码时更推荐 <T> 辅助方法，全程类型安全。

Q7：Comparable<? super T> 里的 ? super 能不能去掉？

不能，去掉会明显收窄适用范围。T extends Comparable<T> 要求元素类型自己实现 Comparable<自己>；现实里大量类的比较能力来自父类（典型：java.sql.Timestamp extends Date，Date implements Comparable<Date>），此时 Comparable<T> 不成立、推断直接报"推论变量 T 具有不兼容的上限"。写成 Comparable<? super T> 就是允许"某个父类型实现了 Comparable"。Collections.max/Collections.sort 都是这个签名；max 里那个 Object & 是为了与泛型前 max(Collection) 的擦除签名保持二进制兼容。

Q8：方法参数什么时候用通配符、什么时候用 <T>？

类型参数在签名的多个位置出现、需要建立关联（参数与参数、参数与返回值）时用 <T>，例如 <T> void copy(List<? super T>, List<? extends T>)、<T> T first(List<? extends T>)；只出现在一个位置、纯为放宽接收范围时用通配符，例如 void print(List<?>)。写成 static <T> void print(List<T>) 能编译，但 T 毫无用途，等价于 List<?>，属于噪音。

10. 小结

泛型不变：List<String> 不是 List<Object>；数组是协变的，代价是 ArrayStoreException 留到运行期。
? extends T = 只读：get 得到 T，add 除 null 外一律编译不过，报错主体是 CAP#1。
? super T = 只写：add(T) 可以，get 只能读成 Object（上界是 Object）。
PECS：Producer Extends, Consumer Super；Stream.map(Function<? super T, ? extends R>) 一个参数位同时体现两条规则。
捕获（CAP#1）用 <T> 辅助方法命名下来；Collections.swap 用原始类型 + @SuppressWarnings 走捷径，取舍写在源码注释里。
List<?>：只读、remove/clear/size 可用、只能 add(null)；<? extends Object> 与它完全等价。
边界里的 ? super：<T extends Comparable<? super T>> 让子类继承父类比较能力时也能用，Collections.max 就是这么写的。

记忆钩子："extends 读、super 写；CAP#1 不认识，<T> 帮它起个名。"

11. 下一步

[ ] 手跑第 8 节代码，对照参考输出。
[ ] 故意编译失败的那几个文件，逐个把报错读一遍，确认自己能解释 CAP#1。
[ ] 随便挑一个 JDK 泛型 API（Stream.map、Collections.addAll）解释它为什么是这个方向。
[ ] 闭卷复述第 9 节 8 个问题。
[ ] 写下一篇：04-泛型在框架中的应用（Spring ResolvableType、Class<T> 的 API 设计、Jackson TypeReference、MyBatis 的泛型 Mapper）。

训练与减脂笔记

从 getClass 说起：理解 Class 对象与泛型擦除

0. 本文要解决什么

1. getClass() 是什么

2. Class 对象是什么

3. 同一个类只有一个 Class 对象

4. getClass()、.class、instanceof 的区别

5. 泛型擦除

6. 为什么 List<String> 和 List<Integer> 的 getClass() 相等

7. 泛型信息真的全没了吗

这和 Spring 依赖注入是什么关系（一个常见错误说法）

8. 为什么不能 new T[]

9. 擦除带来的两个连锁反应

9.1 重载冲突

9.2 桥方法（bridge method）

10. 完整验证代码

11. 面试问法

12. 小结

13. 下一步

擦除之后：桥方法、重载冲突与堆污染

0. 本文要解决什么

1. 擦除之后，编译器在背后插了 checkcast

2. 桥方法：多态为什么还能成立

2.1 问题从哪来

2.2 编译器的解法：合成桥方法

2.3 怎么在代码里识别

3. 重载冲突：擦除后签名撞车

4. 堆污染：异常抛在"读"的地方，不是"写"的地方

4.1 最小复现

4.2 换个马甲：方法参数传原始类型

4.3 可变参数与 @SafeVarargs 的边界

5. 泛型数组：正确写法与它为什么带警告

5.1 直接 new T[] 不行，(T[]) new Object[n] 是骗自己

5.2 唯一正确的方式：显式传 Class

5.3 集合转数组的惯用法

6. 为什么不能 instanceof List<String>

7. 静态成员为什么不能用类的泛型参数

8. 完整验证代码

9. 面试问法

10. 小结

11. 下一步

通配符与 PECS：? extends 与 ? super 到底在限制谁

0. 本文要解决什么

1. 泛型是不变的（invariant）

1.1 一个编译不过的赋值

1.2 为什么必须这样设计：数组的教训

1.3 四条赋值规则（先记方向）

2. ? extends：只读的生产者

2.1 能读到什么

2.2 为什么不能写

2.3 和数组协变对照

3. ? super：只写的消费者

3.1 能写什么

3.2 为什么读出来只能是 Object

3.3 对照表

4. PECS：Producer Extends, Consumer Super

4.1 规则

4.2 自己写三个签名

4.3 JDK 里到处都是 PECS

4.4 方向写反了会怎样

5. 通配符捕获：CAP#1 与 <T> 辅助方法

5.1 一个"看起来显然"却编译不过的 swap

5.2 两种解法：<T> 辅助方法 vs 原始类型

5.3 List<?> 到底能干什么

5.4 List<Object>、List<?>、List<? extends Object>

5.5 什么时候用 <T>、什么时候用通配符

6. Comparable<? super T>：? super 最经典的用法

6.1 先把问题摆出来

6.2 把 T 放宽成"能比较 T 的类型"

6.3 JDK 的原始签名与那个 Object &

6.4 记忆钩子

7. 嵌套通配符：外层不变、内层才放开

8. 完整验证代码

8.1 文件清单

8.2 CovarianceDemo.java

8.3 PecsDemo.java

8.4 CaptureDemo.java

8.5 ComparableDemo.java

8.6 JdkSignatures.java

8.7 MoreRules.java

6. 为什么 `List<String>` 和 `List<Integer>` 的 getClass() 相等

4.3 可变参数与 `@SafeVarargs` 的边界

5.1 直接 `new T[]` 不行，`(T[]) new Object[n]` 是骗自己

6. 为什么不能 `instanceof List<String>`

2. `? extends`：只读的生产者

3. `? super`：只写的消费者

3.2 为什么读出来只能是 `Object`

5. 通配符捕获：`CAP#1` 与 `<T>` 辅助方法

5.2 两种解法：`<T>` 辅助方法 vs 原始类型

5.3 `List<?>` 到底能干什么

5.4 `List<Object>`、`List<?>`、`List<? extends Object>`

5.5 什么时候用 `<T>`、什么时候用通配符

6. `Comparable<? super T>`：`? super` 最经典的用法

6.2 把 `T` 放宽成"能比较 `T` 的类型"

6.3 JDK 的原始签名与那个 `Object &`