Java 泛型：构建类型安全的通用编程范式

炎码工坊

于 2025-06-26 23:29:22 发布

阅读量343

点赞数 7

CC 4.0 BY-SA版权

文章标签： java java-ee

本文链接：https://blog.youkuaiyun.com/like21a/article/details/148935760

🔥「炎码工坊」技术弹药已装填！
点击关注 → 解锁工业级干货【工具实测|项目避坑|源码燃烧指南】

一、泛型的诞生背景

在Java 5引入泛型之前，程序员常常面临这样的困境：

List list = new ArrayList();
list.add("Hello");
list.add(100); // 编译器无法识别类型错误

String str = (String)list.get(0); // 正常
String err = (String)list.get(1); // 运行时异常：ClassCastException

这种基于Object基类的通用编程方式存在两大缺陷：

类型安全性缺失：容器无法约束存储元素的类型
强制类型转换冗余：每次取出元素都需要显式转换

泛型通过编译时类型检查和类型参数化解决了这个根本矛盾。

二、泛型类的核心机制

2.1 基本语法

public class Box<T> {
    private T item;
    
    public void setItem(T item) { 
        this.item = item; 
    }
    
    public T getItem() { 
        return item; 
    }
}

使用示例：

Box<String> stringBox = new Box<>();
stringBox.setItem("Generic");
String content = stringBox.getItem(); // 无需强制转换

Box<Integer> intBox = new Box<>(); 
intBox.setItem(2023);

2.2 类型参数命名规范

E：元素类型（集合框架常用）
K/V：键值对类型
T/U/S：通用类型参数
?：通配符（未知类型）

三、泛型方法的进阶应用

3.1 方法级泛型定义

public class ArrayUtil {
    public static <T> int countIf(T[] array, Predicate<T> predicate) {
        int count = 0;
        for (T item : array) {
            if(predicate.test(item)) count++;
        }
        return count;
    }
}

调用示例：

String[] words = {"Java", "Generics", "Type"};
int longWords = ArrayUtil.countIf(words, s -> s.length() > 4);

3.2 类型推断机制

编译器通过方法参数自动推导类型：

// 实际类型由参数类型推导
int count = ArrayUtil.<String>countIf(words, s -> s.length() > 4); 
// 可简化为
int count = ArrayUtil.countIf(words, s -> s.length() > 4);

四、通配符的复杂应用

4.1 上界通配符（? extends T）

public double calculateTotalArea(List<? extends Shape> shapes) {
    return shapes.stream().mapToDouble(Shape::area).sum();
}

允许传入List<Circle>或List<Square>，但禁止添加元素（除了null）

4.2 下界通配符（? super T）

public void addShapes(List<? super Circle> shapes) {
    shapes.add(new Circle(5.0)); // 安全添加
}

适用于生产者-消费者场景，保证类型兼容性

4.3 无限定通配符（?）

适用于只需要Object方法的操作：

public void printSizes(Collection<?> collection) {
    System.out.println("Size: " + collection.size());
}

五、类型擦除的运行时影响

Java泛型通过类型擦除实现：

// 源码
List<String> strList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();

// 编译后
List strList = new ArrayList();
List intList = new ArrayList();

导致以下限制：

不能创建泛型数组：new T[10]非法
运行时类型检查受限：instanceof List<String>无法实现
静态变量不能引用类型参数：private static T cache;

绕过方案：

// 使用类型令牌
public class TypeToken<T> {
    private final Class<T> type;
    public TypeToken(Class<T> type) { this.type = type; }
    
    public T createInstance() { return type.getConstructor().newInstance(); }
}

六、最佳实践与设计模式

6.1 泛型单例工厂

public class RepositoryFactory {
    @SuppressWarnings("unchecked")
    public static <T> Repository<T> getRepository(Class<T> type) {
        return (Repository<T>) repositories.getOrDefault(type, new DefaultRepository());
    }
}

6.2 管道过滤器模式

public interface Filter<T> {
    boolean apply(T item);
}

public class ChainFilter<T> implements Filter<T> {
    private List<Filter<T>> filters = new ArrayList<>();
    
    public ChainFilter<T> addFilter(Filter<T> filter) {
        filters.add(filter);
        return this;
    }
    
    @Override
    public boolean apply(T item) {
        return filters.stream().allMatch(f -> f.apply(item));
    }
}

七、典型陷阱与解决方案

7.1 原始类型（Raw Type）危害

List rawList = new ArrayList<String>(); 
rawList.add(100); // 编译警告但可执行
String str = (String) rawList.get(0); // 运行时异常

7.2 泛型数组创建

// 错误方式
T[] array = new T[10]; // 编译错误

// 正确实现
public class GenericArray<T> {
    private Object[] elements;
    public GenericArray(int size) { 
        elements = new Object[size]; 
    }
    
    @SuppressWarnings("unchecked")
    public T get(int index) {
        return (T) elements[index];
    }
}

八、现代框架中的泛型实践

Spring Framework中的泛型应用：

public interface Repository<T, ID> {
    T findById(ID id);
    List<T> findAll();
}

public class UserService {
    private final Repository<User, Long> userRepository;
    
    public UserService(Repository<User, Long> userRepository) {
        this.userRepository = userRepository;
    }
}