Java泛型

 

## 一、为什么需要泛型？  
**类型安全案例对比**：  
```java
// Java 5之前
List rawList = new ArrayList();
rawList.add("Hello");
rawList.add(123); // 编译通过但运行时埋雷
String str = (String) rawList.get(1); // 运行时抛出ClassCastException

// 使用泛型
List<String> safeList = new ArrayList<>();
safeList.add("TypeSafe");
// safeList.add(100); // 编译直接报错
String value = safeList.get(0); // 自动转换
```

**核心价值**：  
- 编译时类型检查  
- 消除强制类型转换  
- 增强代码可读性和重用性  

---

## 二、泛型基础语法  

### 1. 泛型类/接口  
```java
public class GenericBox<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// 使用示例
GenericBox<Integer> intBox = new GenericBox<>();
intBox.setContent(100);
Integer num = intBox.getContent(); // 无需强制转换
```

### 2. 泛型方法  
```java
public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
}

// 类型推断
printArray(new String[]{"A", "B", "C"});
```

### 3. 有界类型参数  
```java
public <T extends Number> double sum(List<T> numbers) {
    return numbers.stream().mapToDouble(Number::doubleValue).sum();
}
```

---

## 三、通配符的智慧  

### 1. 上界通配符（生产者）  
```java
public static void printNumbers(List<? extends Number> list) {
    list.forEach(n -> System.out.println(n.doubleValue()));
}
```

### 2. 下界通配符（消费者）  
```java
public static void fillNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}
```

### 3. PECS原则（Producer-Extends, Consumer-Super）  
- 从数据结构获取数据时使用`extends`  
- 向数据结构写入数据时使用`super`  

---

## 四、类型擦除揭秘  
Java泛型通过类型擦除实现向后兼容：  
```java
// 编译前
List<String> strings = new ArrayList<>();

// 编译后（字节码）
List strings = new ArrayList();
```

**擦除带来的限制**：  
- 不能创建泛型数组：`new T[size]`  
- 无法使用`instanceof T`  
- 静态成员不能使用类型参数  

---

## 五、高级技巧与实战  

### 1. 泛型与反射  
```java
public static <T> T createInstance(Class<T> clazz) throws Exception {
    return clazz.getDeclaredConstructor().newInstance();
}
```

### 2. 泛型工厂模式  
```java
interface Factory<T> {
    T create();
}

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

### 3. 类型安全的异构容器  
```java
class TypeSafeContainer {
    private Map<Class<?>, Object> map = new HashMap<>();
    
    public <T> void put(Class<T> type, T instance) {
        map.put(type, type.cast(instance));
    }
    
    public <T> T get(Class<T> type) {
        return type.cast(map.get(type));
    }
}
```

---

## 六、常见陷阱与最佳实践  

**典型错误**：  
```java
// 原生类型警告
List rawList = new ArrayList<String>();

// 不恰当的通配符使用
public static <T> void copy(List<? super T> dest, List<? extends T> src)
```