Java 泛型深度總結：從入門到原理與最佳實踐

一、什麼是泛型？為什麼需要它？

泛型 是 Java 5 引入的參數化類型機制，允許在定義類、接口、方法時使用「類型參數」佔位，實際使用時再指定具體類型。其核心動機是解決集合框架中「只能存 Object、取出需強轉、運行時才發現類型錯誤」的三大痛點。

泛型前後對比

// 無泛型：不安全、需強轉、碼頭費
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 運行時才報 ClassCastException

// 有泛型：編譯期類型安全、無強轉、可讀性強
List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123); // 編譯報錯！
String s = list.get(0); // 無需強轉

二、泛型的四大核心優勢

1. 類型安全：將 ClassCastException 從運行時前移到編譯期。
2. 消除強轉：代碼更乾淨，減少錯誤機會。
3. 代碼復用：一套邏輯服務多種類型 (如 Collections.sort)。
4. 潛在性能優化：為 JVM 逃逸分析、內聯提供更豐富類型信息。

三、泛型核心語法詳解

1. 泛型類/接口

public class Box<T> { // T 為類型參數
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 使用：指定實際類型參數
Box<Integer> intBox = new Box<>();
Box<String> strBox = new Box<>();

2. 命名慣例

3. 泛型方法

方法級別的類型參數化，獨立於類：

public <T> T firstElement(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// 調用：編譯器自動推斷 T
String s = firstElement(Arrays.asList("a", "b"));
Integer i = firstElement(List.of(1, 2));

4. 類型通配符

// 上界通配符：只能讀，不能寫 (生產者)
public void printList(List<? extends Number> list) { 
    for (Number n : list) System.out.println(n);
}

// 下界通配符：只能寫，讀出只能是 Object (消費者)
public void addIntegers(List<? super Integer> list) {
    list.add(1); // OK
    // Number n = list.get(0); // 錯誤：只能賦值給 Object
}

// 無界通配符：僅操作與類型無關的方法 (size, clear, isEmpty)
public void printSize(List<?> list) {
    System.out.println(list.size());
}

5. 有界類型參數

<T extends Number > // T 必須是 Number 或其子類
<T extends Comparable<T>> // T 實現了自比較
<T extends Serializable & Cloneable> // 多重界限

四、泛型擦除：核心原理與衍生限制

Java 泛型採用類型擦除實現：編譯器編譯時檢查類型，生成的字節碼中不包含泛型信息，所有類型參數被替換為其邊界類型 (默認 Object) 或原始類型。

擦除帶來的 5 大限制

1. 不能實例化類型參數：new T()、new T[10] 非法。
   → 解決：反射 clazz.newInstance() 或傳入 Class<T> 工廠。
2. 不能用於 static 成員：static 屬於類，而泛型參數屬於實例。
   → 靜態方法需自行聲明 <T> static void method(T t)。
3. instanceof 不能檢查具體泛型：list instanceof List<String> 非法。
   → 只能 list instanceof List (原始類型)。
4. 不能創建參數化類型數組：new List<String>[10] 非法 (類型安全漏洞)。
   → 使用 List<List<String>> 或 @SafeVarargs。
5. 異常類型不能泛型化：class MyEx<T> extends Exception 非法。

五、Java 集合框架中的泛型進階應用

1. Collection.addAll 通配符設計

interface Collection<E> {
    boolean addAll(Collection<? extends E> c);
}

允許 Collection<Integer> 添加到 Collection<Number>，體現「生產者用 extends」原則 (PECS)。

2. Comparable<T> 自比較模式

public interface Comparable<T> {
    int compareTo(T other);
}

// 正確實現：String implements Comparable<String>
public class String implements Comparable<String> { ... }

// 通用最大值方法
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

3. Class<T> 類型令牌模式

// 獲取泛型實際類型的經典手法 (如 Hibernate DAO)
public abstract class BaseDao<T> {
    private Class<T> entityClass;
    
    @SuppressWarnings("unchecked")
    public BaseDao() {
        // 通過反射獲取子類聲明的泛型參數
        this.entityClass = (Class<T>) ((ParameterizedType) getClass()
            .getGenericSuperclass()).getActualTypeArguments()[0];
    }
    
    public T get(Serializable id) {
        return entityManager.find(entityClass, id); // 類型安全！
    }
}

// 子類無需重寫 getEntityClass()
public class UserDao extends BaseDao<User> { }

六、泛型與數組的愛恨情仇

// 數組是協變的：Integer[] 是 Number[] 的子類
Number[] nums = new Integer[10];
nums[0] = 3.14; // 運行時拋 ArrayStoreException

// 泛型是不變的：List<Integer> 不是 List<Number> 的子類
List<Number> list = new ArrayList<Integer>(); // 編譯錯誤！
// 否則可導致：
// list.add(3.14); // 污染了 Integer 列表
// Integer i = intList.get(0); // ClassCastException

這是為類型安全犧牲靈活性的經典權衡。

七、實戰最佳實踐清單

1. 優先使用泛型集合，拒絕原始類型。
2. 公開 API 必須泛型化，內部實現可視情況簡化。
3. 靈活運用 PECS 原則：Producer Extends, Consumer Super。
4. 避免無意義的通配符：List<?> 僅用於類型無關操作。
5. 利用類型令牌 解決擦除帶來的運行時類型缺失。
6. @SuppressWarnings("unchecked") 只加在最小作用域，並添加註釋說明安全性。
7. 文檔化類型參數約束：Javadoc 標註 @param <T> 必須實現 Serializable。

八、總結

Java 泛型是「編譯期類型安全」與「運行期類型擦除」的精妙平衡。深入理解擦除機制、通配符協變/逆變、PECS 原則、類型令牌模式，是從「會用泛型」進階到「精通泛型設計」的必經之路。合理使用泛型，能讓你的 API 既具備強類型安全，又保持極高的復用靈活性。