Java中的泛型詳細介紹

# Java中的泛型詳細介紹

## 目錄
1. [泛型概述](#泛型概述)
2. [泛型基礎語法](#泛型基礎語法)
3. [泛型類與接口](#泛型類與接口)
4. [泛型方法](#泛型方法)
5. [類型通配符](#類型通配符)
6. [泛型擦除](#泛型擦除)
7. [泛型與數組](#泛型與數組)
8. [泛型最佳實踐](#泛型最佳實踐)
9. [常見面試題](#常見面試題)
10. [總結](#總結)

---

## 泛型概述

### 1.1 什么是泛型
泛型（Generics）是JDK 5引入的類型參數化機制，允許在定義類、接口或方法時使用類型參數，在實際使用時指定具體類型。

**核心價值**：
- 類型安全：編譯時檢查類型匹配
- 消除強制類型轉換
- 提高代碼復用性

### 1.2 泛型發展史
| JDK版本 | 泛型支持 |
|---------|---------|
| JDK 1.0-1.4 | 無泛型，使用Object實現通用容器 |
| JDK 5 (2004) | 引入泛型，兼容舊代碼 |
| JDK 7 (2011) | 鉆石語法（<>）簡化寫法 |
| JDK 8+ | 增強類型推斷能力 |

---

## 泛型基礎語法

### 2.1 基本定義
```java
// 泛型類示例
public class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

2.2 類型參數命名規范

• E：Element（集合元素）
• K：Key（鍵）
• V：Value（值）
• T：Type（通用類型）
• N：Number（數字）
• S/U：第二/第三類型

2.3 使用示例

Box<String> stringBox = new Box<>();
stringBox.setContent("Hello Generics");
String value = stringBox.getContent(); // 無需強制轉型

泛型類與接口

3.1 泛型類定義

public class Pair<K, V> {
    private K key;
    private V value;
    
    // 構造器與方法省略...
}

3.2 泛型接口實現

public interface List<E> {
    void add(E element);
    E get(int index);
}

// 實現方式1：具體類型
class StringList implements List<String> { /*...*/ }

// 實現方式2：保留泛型
class MyList<E> implements List<E> { /*...*/ }

3.3 多類型參數

public class Triple<A, B, C> {
    private A first;
    private B second;
    private C third;
    // ...
}

泛型方法

4.1 基本語法

public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

4.2 靜態泛型方法

public class ArrayUtils {
    public static <T> T getMiddle(T... a) {
        return a[a.length / 2];
    }
}

4.3 類型推斷

// JDK 7+ 可以省略類型參數
List<String> list = Collections.emptyList();

類型通配符

5.1 上界通配符

public void process(List<? extends Number> list) {
    // 允許讀取Number及其子類
    Number n = list.get(0);
}

5.2 下界通配符

public void addNumbers(List<? super Integer> list) {
    // 允許寫入Integer及其父類
    list.add(42);
}

5.3 無界通配符

public void printList(List<?> list) {
    // 僅允許Object類操作
    for (Object elem : list) {
        System.out.println(elem);
    }
}

泛型擦除

6.1 擦除原理

編譯后泛型信息會被擦除，替換為限定類型（未指定則用Object）。

示例對比：

// 源代碼
List<String> list = new ArrayList<>();

// 編譯后等效代碼
List list = new ArrayList();

6.2 橋接方法

編譯器會生成橋接方法保持多態性：

// 泛型接口
interface Comparator<T> {
    int compare(T o1, T o2);
}

// 編譯器生成的橋接方法
int compare(Object o1, Object o2) {
    return compare((String)o1, (String)o2);
}

泛型與數組

7.1 創建泛型數組的限制

// 編譯錯誤
T[] array = new T[10];

// 正確解決方案
@SuppressWarnings("unchecked")
T[] array = (T[]) new Object[10];

7.2 可變參數中的泛型

@SafeVarargs
public final <T> void addAll(T... elements) {
    // 內部實現為數組
}

泛型最佳實踐

8.1 類型安全建議

1. 優先使用泛型方法而非Object強制轉換
2. 避免在public API中使用原始類型
3. 使用@SuppressWarnings時添加說明

8.2 性能考量

• 泛型不會帶來運行時性能開銷
• List與原始List在字節碼層面相同

8.3 設計模式應用

// 泛型工廠模式示例
interface Factory<T> {
    T create();
}

class StringFactory implements Factory<String> {
    public String create() {
        return new String();
    }
}

常見面試題

9.1 基礎問題

Q：List<?>和List