泛型是 Java 5 引入的編譯時類型安全機制，核心是類型擦除。本文深度解析泛型實現原理、通配符與上下界、PECS 原則、類型系統影響、自定義泛型類設計、常見陷阱與最佳實踐，助你寫出類型安全、可讀性強的代碼。
Object，有邊界 → 首個邊界)<T>、<T extends Number> 等)// 源碼
class Box {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
// 擦除後 (JVM 看到)
class Box {
private Object value;
public void set(Object value) { this.value = value; }
public Object get() { return value; }
}
// 子類繼承泛型時的橋接方法
class StringBox extends Box {
// 擦除後父類 set(Object)，子類需保持多態
// 編譯器自動生成橋接方法：
public void set(Object value) { set((String) value); } // 檢查類型後調用具體方法
public void set(String value) { super.set(value); } // 真實業務方法
} | 現象 | 原因 |
|---|---|
無 List，只有 List.class | 運行時類型信息被擦除 |
| 靜態字段/方法不可用類型參數 | 泛型類所有實例共享一個 Class 對象 |
new T()、new T[10] 編譯錯誤 | 運行時不知道 T 具體類型 |
| 異常捕獲不可用泛型 | catch (MyException 非法，JVM 無法區分 |
instanceof List 編譯錯誤 | 運行時只有 List |
| 語法 | 名稱 | 含義 | 可讀取類型 | 可寫入類型 |
|---|---|---|---|---|
List<?> | 無界通配符 | 未知類型，但確定是 Object 子類 | Object | 無 (null 除外) |
List<? extends Number> | 上界通配符 | Number 或其子類 | Number | 無 |
List<? super Integer> | 下界通配符 | Integer 或其父類 (Object/Number) | Object | Integer 及其子類 |
「頻繁讀取 (生產者) 用 extends，頻繁寫入 (消費者) 用 super」
// 生產者：從集合讀取元素 → 用 extends
public void printNumbers(List nums) {
for (Number n : nums) { // 安全讀取為 Number
System.out.println(n.doubleValue());
}
// nums.add(1); // ❌ 編譯錯誤：未知具體子類型，不安全
}
// 消費者：向集合寫入元素 → 用 super
public void addIntegers(List ints) {
ints.add(1); // ✅ 安全：Integer 是 Integer 及其父類的合法子類
ints.add(2);
// Number n = ints.get(0); // ❌ 只能讀取為 Object
Object o = ints.get(0); // ✅ 唯一安全讀取類型
}
// 既讀又寫 → 不用通配符，用具體類型
public void process(List ints) {
ints.add(3);
Integer i = ints.get(0);
} List 是 Collection 子類型 (接口繼承)Collection 子類型包括：
List、SetCollection、CollectionArrayList、HashSet// ❌ 錯誤：List 不是 List public class Pair {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
// ❌ 錯誤：靜態方法/字段不可用類型參數
// private static K staticKey;
// public static K getStaticKey() { ... }
// ❌ 錯誤：無法創建類型參數數組
// public K[] toArray() { return new K[2]; }
// ✅ 正確：數組用 Object[] 或 List
public List keys() { return Arrays.asList(key); }
}
public class Util {
// 靜態泛型方法
public static T first(List list) {
return list.isEmpty() ? null : list.get(0);
}
// 多類型參數
public static Map newHashMap() {
return new HashMap();
}
// 帶上界
public static > T max(Collection coll) {
T max = null;
for (T t : coll) {
if (max == null || t.compareTo(max) > 0) max = t;
}
return max;
}
}
public interface Repository {
T findById(ID id);
List findAll();
T save(T entity);
void deleteById(ID id);
}
// 實現時具體化
public class UserRepository implements Repository { ... }
// 或保持泛型
public class JpaRepositoryImpl implements Repository { ... }
// ❌ 編譯錯誤：不能創建具體泛型數組
List[] stringLists = new List[10];
// ✅ 只能創建無界通配符數組
List[] listArray = new List[10];
// 原因：數組協變 + 泛型不變 = 類型安全漏洞
Object[] objArr = new String[10];
objArr[0] = 1; // 運行時 ArrayStoreException
// 若允許 List[]：
List[] strLists = new List[10];
List[] objLists = strLists; // 數組協變，合法
objLists[0] = Arrays.asList(1, 2); // 編譯合法，運行時將 Integer 放入 List → 崩潰 List → List 或 List，啟用 -Xlint:unchecked/** @param 元素類型 */ <T extends Number > 優於 <T>@SuppressWarnings("unchecked") 僅在證明安全時使用void foo(T... args) 會創建 T[]，堆污染風險，JDK 7+ 用 @SafeVarargs 註解方法
// JDK 7 鑽石操作符
Map> map = new HashMap<>(); // 推斷右側類型參數
// JDK 8 目標類型推斷
List list = Collections.emptyList(); // 推斷為 List
// JDK 10 var + 泛型
var list = new ArrayList(); // 推斷為 ArrayList
var map = new HashMap>(); // 必須顯式指定嵌套類型參數 總結：Java 泛型本質是編譯時類型檢查 + 類型擦除。掌握 PECS 原則、理解 類型擦除後果、避開 泛型數組陷阱、善用 泛型方法/接口、消除 原始類型，是寫出優雅、類型安全 Java 代碼的關鍵。新版本 (JDK 10+) 的 var 與目標類型推斷進一步減少樣板代碼，但核心原理不變。
