#泛型通配符与上下界

List<Number> numbers = new ArrayList<>();
List<? extends Number> list = new ArrayList<Integer>();
list.add(3.14); // ❌ 为什么编译错误？

// extends：生产者 - 只能读
List<? extends Number> list1 = new ArrayList<Integer>();
List<? extends Number> list2 = new ArrayList<Double>();

Number n = list1.get(0); // ✅ 能读取，类型是 Number
// list1.add(3.14); ❌ 编译错误，不能写入

// super：消费者 - 可以写
List<? super Number> list3 = new ArrayList<Number>();
List<? super Number> list4 = new ArrayList<Object>();

list3.add(3.14); // ✅ 能写入 Integer（是 Number 的子类）
Object o = list3.get(0); // 能读取，但类型是 Object（最宽泛）

// 如果允许向 extends 集合写入：
List<Number> numbers = new ArrayList<>();
List<? extends Number> extendsList = new ArrayList<Double>(); // Double extends Number

extendsList.add(new Integer(42)); // 如果允许写入...
numbers = extendsList; // numbers 现在指向 Double 的 List
numbers.get(0); // 返回 Double
Number n = numbers.get(0); // Double 不是 Integer！类型安全问题！

// 因此：extends 集合禁止写入，只能读取

List<? extends Number> list = new ArrayList<Double>();
// list 可能指向 List<Double>, List<Integer>, List<Number>
// 无论哪种，里面的元素一定是 Number 的子类（可能是 Double, Integer, Number）
// 所以读取出来的类型安全，一定能当成 Number 处理
Number n = list.get(0); // ✅ 安全

List<? super Number> list = new ArrayList<Object>();
// list 可能指向 List<Object>, List<Number>
// 无论是哪种，添加 Number 或其子类（Integer, Double）都是安全的
// 因为 Number 是两者都能接收的类型

list.add(new Integer(3));  // ✅ 安全：Integer 是 Number 的子类
list.add(new Double(3.14)); // ✅ 安全：Double 是 Number 的子类
list.add(new Object());     // ❌ 危险：Object 不一定是 Number

List<? super Number> list = new ArrayList<Object>();
// 读取时只能确定是 Object 类型（最宽泛）
Object o = list.get(0); // ✅ 能读取，但类型是 Object
// list.get(0) 返回的不一定是 Number，可能是 Integer，也可能是 String！

// 生产者（提供数据）：用 extends
public double sum(List<? extends Number> numbers) {
    double sum = 0;
    for (Number n : numbers) { // 只能读取 Number
        sum += n.doubleValue();
    }
    return sum;
}

// 消费者（消费数据）：用 super
public void addNumbers(List<? super Integer> list) {
    list.add(1);    // 可以写入 Integer
    list.add(2);
    // 读取只能当 Object，不关心
}

// 如果既要读又要写：用没有通配符的原生类型
public void copy(List<Object> src, List<Object> dest) {
    for (Object item : src) { // 读
        dest.add(item);       // 写
    }
}

// ? 等同于 ? extends Object
List<?> list = new ArrayList<String>();
Object o = list.get(0); // 能读取，但类型是 Object

// 主要用途：处理类型未知或不重要的情况
public boolean isEmpty(List<?> list) {
    return list.size() == 0;
}

// T 是类型参数，? 是通配符
// T 在编译时是确定的
// ? 在编译时是"不确定的某个类型"

class Container<T> {
    void add(T item) { } // T 是确定的类型
    T get() { return null; }
}

class Utils {
    void process(List<?> list) { } // ? 表示某个未知类型
}

List<Object> list1 = new ArrayList<String>(); // ❌ 编译错误
List<?> list2 = new ArrayList<String>(); // ✅ 可以

list1.add(123); // ✅ 可以
list2.add(123); // ❌ 不可以（? 是未知类型，不知道能否写入）

// List<?> 可以持有 List<String>，List<Integer> 等任何类型
// 但写入受限制（因为不知道具体是什么类型）
// List<Object> 可以持有任何 List
// 但读取时需要强制转换（不推荐）

// JDK 源码
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T item : src) {      // src 是生产者，用 extends
        dest.add(item);       // dest 是消费者，用 super
    }
}

// 这正是 PECS 法则的完美应用：
// src 提供数据 → extends
// dest 消费数据 → super