Java泛型详解与项目实战

在Java开发中，泛型（Generics）是一项提升代码类型安全 和复用性的核心技术。下面这张表格汇总了其核心概念和典型应用场景，帮助你快速建立整体认识。

核心概念	核心语法/原则	典型应用场景	主要优势
参数化类型	`类/接口<T>`，`方法<T>`	通用集合类（如`Box<T>`），通用结果封装（如`Result<T>`）	代码复用，一套逻辑适配多种数据类型
类型安全	编译时类型检查	集合框架（如`List<String>`），API设计	编译期发现类型错误，减少`ClassCastException`
类型擦除	编译后泛型信息被擦除	泛型类在运行时无类型参数信息	确保与老版本Java兼容
通配符	`<?>`, `<? extends T>`, `<? super T>`	灵活读取或写入集合，遵循PECS原则	增强API灵活性，处理未知类型或类型继承关系
PECS原则	Producer Extends, Consumer Super	定义数据生产者（读取）和消费者（写入）的边界	指导通配符使用，使代码更安全、灵活

💡 理解泛型基础

泛型的本质是"参数化类型 "，它将具体的类型（如String, Integer）参数化，在定义类、接口或方法时使用这些类型参数（如T），在实际使用时再传入具体的类型。例如，一个简单的泛型类：

swift 复制代码

public class Box<T> { // T 是类型参数
    private T content;
    // ... getter 和 setter
}
// 使用
Box<String> stringBox = new Box<>(); // 此时，T 被具体化为 String 类型
Box<Integer> integerBox = new Box<>(); // 此时，T 被具体化为 Integer 类型

通过这种方式，一套逻辑就可以安全地适用于多种数据类型，无需重复编码。

🛠️ 项目实战应用

1. 统一API结果封装

在Web开发中，前后端交互通常需要返回结构统一的JSON结果，包含状态码、提示信息和业务数据。使用泛型可以优雅地解决不同业务数据类型导致的多份结果类问题。

kotlin 复制代码

// 定义泛型结果类
public class Result<T> {
    private int code;
    private String msg;
    private T data; // 泛型字段，承载业务数据

    // 成功静态工厂方法
    public static <T> Result<T> success(T data) {
        return new Result<>(200, "success", data);
    }
    // ... 其他构造方法和getter
}

// 在Controller中使用
@RestController
public class UserController {
    @GetMapping("/user/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        User user = userService.getById(id);
        return Result.success(user); // 类型安全，data为User类型
    }

    @GetMapping("/users")
    public Result<List<User>> listUsers() {
        List<User> users = userService.listAll();
        return Result.success(users); // 类型安全，data为List<User>类型
    }
}

这种方式避免了为每种返回数据类型（如UserResult, ListResult）编写重复的包装类，极大提升了代码的复用性和可维护性。

2. 通用分页查询结果

分页是业务系统常见需求，返回结果通常包含总记录数、当前页数据列表等信息。使用泛型可以轻松定义通用的分页结果类。

csharp 复制代码

public class PageResult<T> {
    private long total;
    private List<T> list; // 泛型列表，存储分页数据
    private int pageNum;
    private int pageSize;
    // ... 构造方法、getter、setter
}

// 使用示例
public PageResult<Order> getOrdersByPage(int pageNum, int pageSize) {
    List<Order> orderList = orderService.getOrders(pageNum, pageSize);
    long total = orderService.countOrders();
    return new PageResult<>(total, orderList, pageNum, pageSize);
}

3. 策略模式结合泛型

当系统需要根据不同类型执行不同业务逻辑时（如处理不同类型的凭证），可以结合策略模式和泛型，实现高内聚、低耦合的设计。

typescript 复制代码

// 1. 定义泛型处理器接口
public interface Handler<T> {
    boolean supports(Class<?> clazz); // 判断是否支持处理该类型
    void handle(T data); // 处理数据
}

// 2. 实现具体处理器
@Component
public class EcouponHandler implements Handler<Ecoupon> {
    @Override
    public boolean supports(Class<?> clazz) {
        return Ecoupon.class.isAssignableFrom(clazz);
    }
    @Override
    public void handle(Ecoupon ecoupon) {
        // 处理电子券的专属逻辑
    }
}

// 3. 处理器工厂，统一调度
@Service
public class HandlerManager {
    @Autowired
    private List<Handler<?>> handlers; // 注入所有处理器

    public <T> void process(T data) {
        for (Handler<?> handler : handlers) {
            if (handler.supports(data.getClass())) {
                ((Handler<T>) handler).handle(data); // 类型安全转换后处理
                return;
            }
        }
        throw new UnsupportedOperationException("无支持处理器");
    }
}

这种设计符合开闭原则，新增凭证类型时，只需添加新的Handler实现即可，无需修改原有代码。

4. 应对泛型擦除：JSON反序列化

由于Java泛型在编译后存在类型擦除 （Type Erasure），运行时无法直接获取List<String>中的String类型信息。这在处理JSON反序列化时会带来问题。可以通过TypeReference保留泛型信息。

java 复制代码

// 定义TypeReference
public abstract class TypeReference<T> {
    private final Type type;
    protected TypeReference() {
        // 通过获取父类的ParameterizedType来保留泛型信息
        Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }
    public Type getType() { return type; }
}

// JSON工具类
public class JsonUtil {
    private static final Gson GSON = new Gson();
    public static <T> T fromJson(String json, TypeReference<T> typeReference) {
        return GSON.fromJson(json, typeReference.getType()); // 传入完整的类型信息
    }
}

// 使用示例：反序列化复杂泛型类型
String json = "[{"name":"Alice"}, {"name":"Bob"}]";
// 使用匿名内部类创建TypeReference子类，保留List<User>的完整类型信息
List<User> users = JsonUtil.fromJson(json, new TypeReference<List<User>>() {});

这里的关键在于new TypeReference<List<User>>() {}创建了一个匿名子类，其父类的泛型参数List<User>信息在运行时可通过反射获取，从而绕过类型擦除的限制。

⚠️ 重要限制与最佳实践

类型擦除 ：泛型信息在编译期后被擦除，例如List<String>和List<Integer>在运行时都是List。因此，不能直接使用new T()创建实例，也不能用instanceof检查泛型类型（如list instanceof List<String>）。
PECS原则 ：使用通配符? extends T和? super T时，牢记Producer Extends, Consumer Super 原则。当主要从泛型结构读取（生产者）时，使用? extends T；当主要向其中写入（消费者）时，使用? super T。这能显著增强API的灵活性。
不能用于基本类型 ：泛型类型参数不能是基本数据类型（如int, double），而应使用其包装类（如Integer, Double）。
避免混合使用原始类型 ：应始终使用带泛型参数的类型（如List<String>），避免使用原始类型（如List），以获得编译期的类型安全检查。

💎 总结

Java泛型通过参数化类型，在编译阶段提供类型安全检查，大大提升了代码的健壮性、复用性和可读性。掌握泛型，理解其核心机制如类型擦除，并能在实际项目中灵活运用（如统一返回封装、分页处理、策略模式等），是编写高质量Java代码的关键一步。希望这些详解和实战示例能帮助你更好地掌握Java泛型。