Java 泛型通配符 ＜? extends＞ vs ＜? super＞ 实战场景

// Java 17+支持
import java.util.ArrayList;
import java.util.List;
 
public class ExtendsDemo {
    // 统计数字集合的总和（仅读取，生产者）
    public static double sum(List<? extends Number> numberList) {
        double total = 0.0;
        for (Number num : numberList) {
            total += num.doubleValue(); // 读取为Number类型，安全
        }
        // numberList.add(10); // 编译报错：<? extends Number> 禁止添加元素
        return total;
    }
 
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(10);
        intList.add(20);
        
        List<Double> doubleList = new ArrayList<>();
        doubleList.add(3.14);
        doubleList.add(6.28);
        
        // 支持Integer、Double等Number子类集合
        //http://fycj.tm66d.cn 
        System.out.println("整数列表总和：" + sum(intList)); // 输出30.0
        System.out.println("小数列表总和：" + sum(doubleList)); // 输出9.42
    }
 
}

// Java 17+支持
import java.util.ArrayList;
import java.util.List;
 
public class SuperDemo {
    // 向集合中添加整数（仅写入，消费者）
    public static void addIntegers(List<? super Integer> integerList) {
        integerList.add(10); // 可添加Integer类型
        integerList.add(20); // 可添加Integer子类（此处无子类，直接加Integer）
        // integerList.add(3.14); // 编译报错：Double不是Integer的子类
        
        // 读取时仅能转为Object
        for (Object obj : integerList) {
            System.out.println("元素：" + obj);
        }
    }
 
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        List<Number> numberList = new ArrayList<>();
        List<Object> objList = new ArrayList<>();
        
        // 支持Integer、Number、Object等父类集合
        addIntegers(intList); // 输出：10、20
        addIntegers(numberList); // 输出：10、20
        addIntegers(objList); // 输出：10、20
    }
}

// Java 17+支持
import java.util.Collection;
import java.util.List;
 
public class CollectionUtils {
    /**
     * 批量添加元素到集合（消费者场景，用<? super T>）
     * @param dest 目标集合（接收元素）
     * @param elements 待添加元素（T或T的子类）
     */
    @SafeVarargs
    public static <T> boolean addAll(Collection<? super T> dest, T... elements) {
        boolean modified = false;
        for (T elem : elements) {
            modified |= dest.add(elem); // 写入安全，编译通过
        }
        return modified;
    }
 
    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        Integer[] ints = {1, 2, 3};
        Double[] doubles = {4.0, 5.0};
        
        // 向Number集合添加Integer、Double（Number的子类）
        addAll(numberList, ints); 
        addAll(numberList, doubles);
        
        System.out.println(numberList); // 输出：[1, 2, 3, 4.0, 5.0]
    }
}

// Java 17+支持
import java.util.List;
 
public class GenericCombinationDemo {
    /**
     * 从源集合读取数据（extends），写入目标集合（super）
     * @param source 源集合（生产者）
     * @param dest 目标集合（消费者）
     */
    public static <T> void copy(List<? extends T> source, List<? super T> dest) {
        for (T elem : source) {
            dest.add(elem); // 源集合取T类型，目标集合存T类型，双向安全
        }
    }
 
    public static void main(String[] args) {
        List<Integer> intSource = List.of(1, 2, 3); // Java 9+ List.of()，Java 17+兼容
        List<Number> numberDest = new ArrayList<>();
        List<Object> objDest = new ArrayList<>();
        
        // 从Integer集合复制到Number、Object集合
        copy(intSource, numberDest);
        copy(intSource, objDest);
        
        System.out.println(numberDest); // 输出：[1, 2, 3]
        System.out.println(objDest); // 输出：[1, 2, 3]
    }
}

List<? extends Number> list = new ArrayList<Integer>();
list.add(10); // 编译报错：The method add(capture#1-of ? extends Number) is undefined for the type List<capture#1-of ? extends Number>

List<Number> list = new ArrayList<Integer>(); // 直接用具体类型接收，或用<? super T>
list.add(10);

List<? super Integer> list = new ArrayList<Number>();
list.add(10);
Integer num = (Integer) list.get(0); // 编译警告，运行时可能报错

List<? super Integer> list = new ArrayList<Number>();
list.add(10);
Object obj = list.get(0); // 仅能安全转为Object
if (obj instanceof Integer) {
    Integer num = (Integer) obj; // 加类型判断，避免强转异常
}

// 无需通配符，直接用具体泛型即可
public static void process(List<? extends Object> list) {
    // 逻辑...
}

public static void process(List<Object> list) {
    // 逻辑...
}

List<? extends Number>[] arr = new List<Integer>[10]; 
// 编译报错：Generic array creation 

List<? extends Number>[] arr = new List[10]; // 用原始类型数组（不推荐）
// 或优先用集合替代数组：
List<List<? extends Number>> list = new ArrayList<>();

// 返回值用通配符，调用方需额外处理类型，体验差
public static List<? extends Number> createList() {
    return new ArrayList<Integer>();
}

// 直接返回具体泛型类型，或用泛型方法
public static List<Integer> createList() {
    return new ArrayList<Integer>();
}
// 或支持多种类型：
public static <T extends Number> List<T> createList(Class<T> clazz) {
    return new ArrayList<>();
}