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