java泛型

Java 泛型详解：用法、原理与最佳实践

一、泛型的核心概念

1.1 什么是泛型

泛型（Generics） 是 Java 5 引入的类型参数化机制，允许在定义类、接口和方法时使用类型参数。它提供了编译时类型安全检查，消除了运行时的 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();
}

// 实现
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）

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;  // 编译错误！不兼容类型

// 但通配符可实现部分兼容
List<?> unknownList = strList;        // 安全
List<? extends Object> objList = strList; // 安全

四、类型擦除原理

4.1 擦除机制

Java 泛型是通过类型擦除（Type Erasure） 实现的：

1. 编译时：检查泛型类型安全性

2. 运行时：擦除类型参数，替换为边界类型

   • 无边界：替换为 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);
}

// 实现类
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 使用原则

1. PECS原则（Producer-Extends, Consumer-Super）：

   • 只读取数据时用 ? extends T

   • 只写入数据时用 ? super T

   • 既要读又要写时不要用通配符

2. 避免原始类型：

java
List list = new ArrayList();     // 原始类型（不推荐）
List<String> list = new ArrayList<>();  // 参数化类型（推荐）

5.2 常见陷阱与解决方案

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 函数式接口

java
// 泛型函数式接口
@FunctionalInterface
interface Converter<T, R> {
    R convert(T from);
}

// 使用
Converter<String, Integer> converter = Integer::parseInt;
int num = converter.convert("123");

6.3 自定义数据容器

java
public class Response<T> {
    private boolean success;
    private T data;
    private String error;
    
    // 静态工厂方法
    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());

总结：泛型核心要点

最佳实践建议：

1. 始终使用参数化类型，避免原始类型

2. 优先考虑泛型方法而非泛型类

3. 使用有界通配符增加API灵活性

4. 类型安全优先于代码简洁性

5. 了解类型擦除的影响，必要时传递Class对象

通过合理使用泛型，可以显著提高Java代码的健壮性、可读性和可维护性，是现代Java开发的核心技能之一。