Java 泛型詳解：用法、原理與最佳實踐
一、泛型的核心概念
1.1 什么是泛型
泛型（Generics） 是 Java 5 引入的類型參數(shù)化機制，允許在定義類、接口和方法時使用類型參數(shù)。它提供了編譯時類型安全檢查，消除了運行時的 ClassCastException 風險。
1.2 為什么需要泛型
java
// 泛型前（易出錯）
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 需要顯式轉換
// 泛型后（類型安全）
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // 自動類型推斷
二、泛型的基本用法
2.1 泛型類
java
public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}
// 使用
Box<String> stringBox = new Box<>();
stringBox.setContent("Java Generics");
String value = stringBox.getContent(); // 無需強制轉換
2.2 泛型接口
java
public interface Pair<K, V> {
K getKey();
V getValue();
}
// 實現(xiàn)
public class OrderedPair<K, V> implements Pair<K, V> {
private K key;
private V value;
public OrderedPair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
// 使用
Pair<String, Integer> p1 = new OrderedPair<>("Age", 25);
2.3 泛型方法
java
public class Util {
// 泛型方法定義
public static <T> T getMiddle(T... a) {
return a[a.length / 2];
}
}
// 使用
String middle = Util.<String>getMiddle("John", "Q.", "Public");
// 類型推斷（更簡潔）
Integer midNum = Util.getMiddle(1, 2, 3);
三、高級泛型特性
3.1 類型通配符（Wildcards）
| 通配符類型 | 含義 | 示例 |
|---|---|---|
| <?> | 未知類型（無限定） | List<?> |
| <? extends T> | T 或其子類（上界通配符） | List<? extends Number> |
| <? super T> | T 或其父類（下界通配符） | List<? super Integer> |
java
// 上界通配符：只能讀取，不能添加（除null外）
public static double sumOfList(List<? extends Number> list) {
double sum = 0.0;
for (Number n : list) {
sum += n.doubleValue();
}
return sum;
}
// 下界通配符：可以添加T及其子類
public static void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
}
3.2 泛型與繼承
java
// 泛型類不支持直接繼承
List<String> strList = new ArrayList<>();
// List<Object> objList = strList; // 編譯錯誤！不兼容類型
// 但通配符可實現(xiàn)部分兼容
List<?> unknownList = strList; // 安全
List<? extends Object> objList = strList; // 安全
四、類型擦除原理
4.1 擦除機制
Java 泛型是通過類型擦除（Type Erasure） 實現(xiàn)的：
編譯時：檢查泛型類型安全性
-
運行時：擦除類型參數(shù)，替換為邊界類型
- 無邊界：替換為 Object
- 有邊界：替換為邊界類型
java
// 編譯前
public class Box<T extends Comparable<T>> {
private T value;
public void set(T v) { value = v; }
}
// 編譯后（通過反編譯查看）
public class Box {
private Comparable value; // T 被擦除為 Comparable
public void set(Comparable v) { value = v; }
}
4.2 橋接方法
java
// 泛型接口
interface Processor<T> {
void process(T item);
}
// 實現(xiàn)類
class StringProcessor implements Processor<String> {
public void process(String s) {
System.out.println(s);
}
}
// 編譯后生成的橋接方法
class StringProcessor implements Processor {
public void process(String s) { ... } // 實際方法
// 編譯器生成的橋接方法
public void process(Object o) {
process((String) o); // 類型轉換
}
}
五、泛型最佳實踐
5.1 使用原則
-
PECS原則（Producer-Extends, Consumer-Super）：
只讀取數(shù)據(jù)時用 ? extends T
只寫入數(shù)據(jù)時用 ? super T
既要讀又要寫時不要用通配符
避免原始類型：
java
List list = new ArrayList(); // 原始類型（不推薦）
List<String> list = new ArrayList<>(); // 參數(shù)化類型（推薦）
5.2 常見陷阱與解決方案
| 問題類型 | 解決方案 |
|---|---|
| 不能實例化泛型類型 | 使用工廠方法或Class對象 |
| 不能創(chuàng)建泛型數(shù)組 | 使用ArrayList替代 |
| 靜態(tài)成員不能泛型化 | 使用泛型方法替代 |
| 類型擦除導致信息丟失 | 運行時傳遞Class對象保留類型信息 |
java
// 通過Class對象保留類型信息
public static <T> T createInstance(Class<T> clazz)
throws InstantiationException, IllegalAccessException {
return clazz.newInstance();
}
六、真實應用場景
6.1 集合框架
java
// 類型安全的集合
Map<String, List<Integer>> scores = new HashMap<>();
scores.put("Alice", Arrays.asList(90, 85, 92));
6.2 函數(shù)式接口
java
// 泛型函數(shù)式接口
@FunctionalInterface
interface Converter<T, R> {
R convert(T from);
}
// 使用
Converter<String, Integer> converter = Integer::parseInt;
int num = converter.convert("123");
6.3 自定義數(shù)據(jù)容器
java
public class Response<T> {
private boolean success;
private T data;
private String error;
// 靜態(tài)工廠方法
public static <U> Response<U> success(U data) {
Response<U> response = new Response<>();
response.success = true;
response.data = data;
return response;
}
}
// 使用
Response<User> userResponse = Response.success(new User());
總結：泛型核心要點
| 特性 | 關鍵點 |
|---|---|
| 類型安全 | 編譯時檢查類型錯誤，避免ClassCastException |
| 代碼復用 | 一套代碼支持多種類型 |
| 消除強制轉換 | 減少冗余的類型轉換代碼 |
| 通配符靈活性 | <? extends T> 和 <? super T> 提供更靈活的API設計 |
| 類型擦除 | 運行時類型信息被擦除，需通過其他方式保留類型信息 |
| PECS原則 | Producer-Extends, Consumer-Super 指導通配符使用 |
最佳實踐建議：
始終使用參數(shù)化類型，避免原始類型
優(yōu)先考慮泛型方法而非泛型類
使用有界通配符增加API靈活性
類型安全優(yōu)先于代碼簡潔性
了解類型擦除的影響，必要時傳遞Class對象
通過合理使用泛型，可以顯著提高Java代碼的健壯性、可讀性和可維護性，是現(xiàn)代Java開發(fā)的核心技能之一。
