Java 泛型深度解析：類型參數化、通配符、擦除機制與 Eclipse 開發實戰

泛型：Java 邁向類型安全的關鍵一步

J2SE 5.0 引入泛型，實現類型參數化，將類型檢查從運行時前移到編譯期，徹底解決集合框架「只能存 Object、取出需強轉、運行時才發現類型錯誤」的痛點。

核心語法與聲明形式

1. 泛型類

// 最簡單泛型類
public class Box { }

// 實用泛型類：類型安全的列表
public class GenList {
    private T[] elements;
    private int size = 0;
    
    @SuppressWarnings("unchecked")
    public GenList(int capacity) {
        elements = (T[]) new Object[capacity]; // 必須轉型，無法 new T[]
    }
    
    public void add(T e) {
        if (size < elements.length) elements[size++] = e;
    }
    
    public T get(int index) {
        if (index >= 0 && index < size) return elements[index];
        return null;
    }
}

2. 泛型接口

public interface Processor {
    void process(T item);
}

// 多類型參數
public interface Map {
    V get(K key);
    V put(K key, V value);
}

3. 泛型方法

// 靜態工具方法常用泛型方法
public static  void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

// 限定類型參數上界
public static > T max(T[] array) {
    T max = array[0];
    for (T e : array) if (e.compareTo(max) > 0) max = e;
    return max;
}

4. 有界類型參數

// 上界：T 必須是 Number 或其子類
public class NumberBox {
    private T value;
    public void set(T value) { this.value = value; }
    public double doubleValue() { return value.doubleValue(); }
}

// 使用
NumberBox intBox = new NumberBox<>(); // OK
NumberBox strBox = new NumberBox<>();  // 編譯錯誤：String 不是 Number

類型擦除：泛型的運行時真相

Java 泛型採用類型擦除：編譯器將泛型類型替換為原始類型，必要時插入強制轉型。運行時不存在泛型類型信息。

擦除規則

• 無界類型參數 → 擦除為 Object
• 有界類型參數 → 擦除為第一個界限 (如 T extends Number & Comparable → Number)
• 泛型數組創建非法：new T[10]、new List[10] 皆編譯錯誤
• 靜態字段/方法不能引用類型參數
• 異常類型不能是泛型

擦除帶來的限制與對策

通配符：泛型的靈活性核心

三種通配符形式

// 1. 無界通配符：表示「未知類型」，只能讀取 Object、不能寫入 (除 null)
List unknownList = new ArrayList();
Object obj = unknownList.get(0); // OK
// unknownList.add("test"); // 編譯錯誤

// 2. 上界通配符：? extends T —— 生產者 (Producer) —— 只讀不寫
List nums = new ArrayList();
Number n = nums.get(0); // OK，安全讀取為 Number
// nums.add(1); // 編譯錯誤：不能寫入，因為可能是 List

// 3. 下界通配符：? super T —— 消費者 (Consumer) —— 只寫不讀 (讀出是 Object)
List ints = new ArrayList();
ints.add(1); // OK，Integer 是 Number 子類
// Number n = ints.get(0); // 編譯錯誤：只能讀為 Object
Object o = ints.get(0); // OK

PECS 原則：Producer Extends, Consumer Super

// 經典案例：Collections.copy
public static  void copy(List dest, List src) {
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i)); // src 只讀 (extends)，dest 只寫 (super)
    }
}

// 方法簽名設計指南：
// - 如果參數只用於「讀取/生產」元素 → 用 ? extends T
// - 如果參數只用於「寫入/消費」元素 → 用 ? super T
// - 如果既要讀又要寫 → 用精確類型 T (不帶通配符)

Eclipse 開發環境支持

• 類創建向導：New → Class → Type Parameters 欄位輸入 T 或 K,V
• 接口創建向導：同樣支持類型參數聲明
• 實時錯誤提示：類型不匹配、擦除衝突、未檢查轉型黃色警告
• 快速修復：添加 @SuppressWarnings("unchecked")、推斷類型參數
• 類型層次視圖：顯示泛型接口實現關係 (如 ArrayList implements List)

實戰最佳實踐

1. API 設計：優先使用泛型

// 良好的 API
public interface Repository {
    T findById(ID id);
    List findAll();
    T save(T entity);
    void deleteById(ID id);
}

// 避免：原始類型
public interface RawRepository {
    Object findById(Object id); // 類型不安全
}

2. 靜態工廠方法簡化構造

public class Pair {
    private final K key;
    private final V value;
    
    private Pair(K key, V value) { this.key = key; this.value = value; }
    
    // 類型推導，調用無需顯式指定類型
    public static  Pair of(K key, V value) {
        return new Pair<>(key, value);
    }
}

// 使用
Pair pair = Pair.of("age", 25); // 自動推導

3. 避免原始類型

// 壞習慣
List list = new ArrayList(); // 原始類型，失去類型檢查
list.add("hello");
list.add(123); // 編譯通過，運行時崩潰

// 好習慣
List