泛型深入：擦除机制、通配符 PECS 与桥方法

List<String> strList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();

// 问：下面这行代码能编译通过吗？
boolean same = strList.getClass() == intList.getClass();

// ① 无界类型参数 —— T 可以是任何引用类型
public class Box<T> {
    private T value;
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

// ② 有界类型参数 —— T 必须是 Comparable 的子类型
public class SortedBox<T extends Comparable<T>> {
    private T value;
    public int compare(T other) {
        return value.compareTo(other); // 编译器确认 compareTo 存在
    }
}

// ③ 多重约束 —— T 必须同时满足多个条件（最多一个类 + 多个接口）
public class Tagged<T extends Number & Comparable<T> & Serializable> {
    private T value;
}

// ──── 你写的代码 ────
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

// ──── 编译器生成的字节码（擦除后） ────
List list = new ArrayList();       // <String> 被擦掉了
list.add("hello");
String s = (String) list.get(0);  // 编译器自动插入强制转型

// ❌ 限制1：不能创建泛型类型的数组
T[] arr = new T[10];          // 编译错误！T 已被擦除，JVM 不知道数组元素类型

// ❌ 限制2：不能对泛型类型使用 instanceof
if (obj instanceof List<String>) // 编译错误！运行时 List<String> 和 List<Integer> 无法区分

// ❌ 限制3：不能使用基本类型作为类型参数
List<int> nums;                 // 编译错误！只能用 List<Integer>（自动装箱）

// ❌ 限制4：不能创建泛型类型的实例
T obj = new T();              // 编译错误！不知道 T 的无参构造器是否存在

// ❌ 限制5：泛型类的静态成员不能使用类的类型参数
public class Box<T> {
    static T sharedValue;         // 编译错误！静态成员属于类本身，不属于某个实例化的 T
}

List<Integer> intList = new ArrayList<>();
List<Number> numList = intList;  // ❌ 编译错误！
// Integer 是 Number 的子类，但 List<Integer> 不是 List<Number> 的子类
// 如果允许赋值，下面这行就会破坏类型安全：
numList.add(3.14);               // 往 Integer 列表里塞了 Double！

// ═══ ? extends T（上界通配符）═══  "Producer Extends"
// 含义：列表里装的是 T 或 T 的某个子类 → 只能读，不能写
public static double sum(List<? extends Number> list) {
    double total = 0;
    for (Number n : list) {        // ✅ 读出来一定是 Number 或其子类，安全
        total += n.doubleValue();
    }
    // list.add(42);                // ❌ 编译错误！不知道具体是 Integer 还是 Double
    return total;
}

// ═══ ? super T（下界通配符）═══  "Consumer Super"
// 含义：列表里装的是 T 或 T 的某个父类 → 只能写，读出来是 Object
public static void addNumbers(List<? super Integer> list) {
    list.add(1);                    // ✅ 写入 Integer 一定安全（父类都能装 Integer）
    list.add(2);
    // Integer val = list.get(0);   // ❌ 编译错误！读出来可能是 Number 或 Object
    Object obj = list.get(0);     // ✅ 只能当 Object 用
}

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    // src 是生产者（extends）：只读取
    // dest 是消费者（super）：只写入
    ListIterator<? super T> di = dest.listIterator();
    ListIterator<? extends T> si = src.listIterator();
    while (si.hasNext()) {
        di.next();
        di.set(si.next());  // 从 src 读，往 dest 写
    }
}

public class Node<T> {
    public T data;
    public void setData(T data) { this.data = data; }
}

public class StringNode extends Node<String> {
    @Override
    public void setData(String data) { this.data = data; }
}

// 你写的 setData(String) —— 真正的方法
public void setData(java.lang.String);
  Code:
    0: aload_0
    1: aload_1
    2: putfield      #2  // Field data:Ljava/lang/String;
    5: return

// 编译器生成的桥方法 setData(Object) —— 用于保持多态
public void setData(java.lang.Object);   // ← 参数类型匹配父类
  Code:
    0: aload_0
    1: aload_1
    2: checkcast     #3  // class java/lang/String  ← 强制转型
    5: invokevirtual #4  // Method setData(String)  ← 转调真正的方法
    8: return

// Guava 的 TypeToken（或 Gson 的 TypeToken）
TypeToken<List<String>> token = new TypeToken<List<String>>() {};
//                                          匿名子类 ↑↑↑

Type type = token.getType();
// → java.util.List<java.lang.String>  泛型信息完整保留！

// 经典的自限定类型：Comparable<T> 要求 T 能与自身比较
public class Student implements Comparable<Student> {
    private int score;
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.score, other.score);
    }
}

// 泛型工具方法 —— 要求 T 能与自身比较
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// 调用
Student winner = max(student1, student2); // 编译期就保证类型安全

// 通配符不能直接修改元素——但可以用捕获转换"捕获"通配符类型
public static void swap(List<?> list, int i, int j) {
    // list.set(i, list.set(j, list.get(i)));  // ❌ 通配符不允许 set
    swapHelper(list, i, j);                     // 通过泛型方法捕获类型
}

private static <T> void swapHelper(List<T> list, int i, int j) {
    list.set(i, list.set(j, list.get(i)));      // ✅ T 是确定类型，可以读写
}

// ❌ 错误1：把泛型集合赋值给更宽泛的泛型集合
List<Integer> ints = new ArrayList<>();
List<Number> nums = ints;      // 编译错误！用 List<? extends Number>

// ❌ 错误2：在 ? extends 通配符集合上调用 add
List<? extends Number> list = ...;
list.add(42);                    // 编译错误！extends 只读

// ❌ 错误3：对泛型类型使用 instanceof
if (obj instanceof List<String>) // 编译错误！运行时无法区分

// ❌ 错误4：创建泛型数组
T[] arr = new T[10];          // 编译错误！用 Object[] 或 Array.newInstance

// ❌ 错误5：反射时忘记过滤桥方法
for (Method m : clazz.getDeclaredMethods()) {
    if (!m.isBridge()) { ... }  // 必须排除桥方法
}