// Java 17+支持
import java.util.ArrayList;
import java.util.List;
 
public class ExtendsDemo {
    // 統(tǒng)計(jì)數(shù)字集合的總和（僅讀取，生產(chǎn)者）
    public static double sum(List<? extends Number> numberList) {
        double total = 0.0;
        for (Number num : numberList) {
            total += num.doubleValue(); // 讀取為Number類型，安全
        }
        // numberList.add(10); // 編譯報(bào)錯(cuò)：<? 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("整數(shù)列表總和：" + sum(intList)); // 輸出30.0
        System.out.println("小數(shù)列表總和：" + sum(doubleList)); // 輸出9.42
    }
 
}

// Java 17+支持
import java.util.ArrayList;
import java.util.List;
 
public class SuperDemo {
    // 向集合中添加整數(shù)（僅寫入，消費(fèi)者）
    public static void addIntegers(List<? super Integer> integerList) {
        integerList.add(10); // 可添加Integer類型
        integerList.add(20); // 可添加Integer子類（此處無子類，直接加Integer）
        // integerList.add(3.14); // 編譯報(bào)錯(cuò)：Double不是Integer的子類
        
        // 讀取時(shí)僅能轉(zhuǎn)為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 {
    /**
     * 批量添加元素到集合（消費(fèi)者場(chǎng)景，用<? super T>）
     * @param dest 目標(biāo)集合（接收元素）
     * @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 {
    /**
     * 從源集合讀取數(shù)據(jù)（extends），寫入目標(biāo)集合（super）
     * @param source 源集合（生產(chǎn)者）
     * @param dest 目標(biāo)集合（消費(fèi)者）
     */
    public static <T> void copy(List<? extends T> source, List<? super T> dest) {
        for (T elem : source) {
            dest.add(elem); // 源集合取T類型，目標(biāo)集合存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集合復(fù)制到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); // 編譯報(bào)錯(cuò)：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); // 編譯警告，運(yùn)行時(shí)可能報(bào)錯(cuò)

List<? super Integer> list = new ArrayList<Number>();
list.add(10);
Object obj = list.get(0); // 僅能安全轉(zhuǎn)為Object
if (obj instanceof Integer) {
    Integer num = (Integer) obj; // 加類型判斷，避免強(qiáng)轉(zhuǎn)異常
}

// 無需通配符，直接用具體泛型即可
public static void process(List<? extends Object> list) {
    // 邏輯...
}

public static void process(List<Object> list) {
    // 邏輯...
}

List<? extends Number>[] arr = new List<Integer>[10]; 
// 編譯報(bào)錯(cuò)：Generic array creation 

List<? extends Number>[] arr = new List[10]; // 用原始類型數(shù)組（不推薦）
// 或優(yōu)先用集合替代數(shù)組：
List<List<? extends Number>> list = new ArrayList<>();

// 返回值用通配符，調(diào)用方需額外處理類型，體驗(yàn)差
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<>();
}