在Java开发中，泛型是一个既基础又容易被忽视的核心特性。从JDK 5引入至今，它已经成为集合框架、框架开发、工具类设计中不可或缺的部分。然而，很多开发者对泛型的理解仅停留在“List<String>避免类型转换”的表层，面对T、E、K、V与?的区别，以及上界、下界通配符的使用场景时常常感到困惑。本文将从泛型的本质出发，结合源码案例与实战场景，全面解析泛型的核心价值、通配符差异及最佳实践，帮你真正做到“知其然，更知其所以然”。

一、泛型的本质：为什么需要泛型？

在讨论通配符之前，我们首先要明确泛型的核心目标——参数化类型。简单来说，就是将类型从“固定”变为“可配置”，让类、接口、方法能适配多种数据类型，同时在编译阶段保证类型安全。

1.1 泛型解决的4大核心问题

在泛型出现之前，Java通过Object类型实现“通用”，但这种方式存在严重缺陷。我们通过对比“非泛型写法”与“泛型写法”，看泛型如何解决这些问题：

（1）类型安全：编译期拦截错误，避免运行时崩溃

非泛型依赖Object存储数据，编译时无法检查类型，运行时强制转换可能抛出ClassCastException，这是Java中最常见的运行时错误之一。

// 非泛型写法：存在类型转换风险
List list = new ArrayList();
list.add("Java泛型");  // 存入String
list.add(123);        // 存入Integer（编译不报错，隐藏风险）

// 运行时错误：Integer无法转换为String
String str = (String) list.get(1);  // 抛出ClassCastException

泛型通过“类型参数”在编译期约束数据类型，非法类型直接报错，从源头避免风险：

// 泛型写法：指定List只能存储String
List<String> stringList = new ArrayList<>();
stringList.add("Java泛型");  // 合法
// stringList.add(123);      // 编译报错：不兼容的类型: int无法转换为java.lang.String

// 无需强制转换，编译期已确认类型
String str = stringList.get(0);  // 安全

（2）消除冗余转换：减少代码噪音，提升可读性

非泛型场景下，每次从集合中获取数据都需要强制转换，代码冗余且易出错。以Map为例：

// 非泛型Map：每次get都要强制转换
Map userMap = new HashMap();
userMap.put("admin", new User("admin", "123456"));
User admin = (User) userMap.get("admin");  // 必须强制转换

泛型通过“键值对类型约束”，自动完成类型转换：

// 泛型Map：指定键为String，值为User
Map<String, User> userMap = new HashMap<>();
userMap.put("admin", new User("admin", "123456"));
User admin = userMap.get("admin");  // 无需转换，直接获取User类型

（3）代码复用：一套逻辑适配多类型，避免重复开发

没有泛型时，为不同类型编写相似逻辑会产生大量重复代码。例如，实现“数据包装类”需要为String、Integer、User分别编写：

// 非泛型：为String编写的包装类
class StringWrapper {
    private String data;
    public String getData() { return data; }
    public void setData(String data) { this.data = data; }
}

// 非泛型：为User编写的包装类（逻辑完全重复，仅类型不同）
class UserWrapper {
    private User data;
    public User getData() { return data; }
    public void setData(User data) { this.data = data; }
}

泛型只需一套代码，即可适配所有类型。例如，Spring Boot中常用的“统一响应结果类”：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 泛型统一响应结果类：适配所有数据类型的接口返回
 * @param <T> 响应数据的类型（如List<User>、User、String等）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
    private int code;          // 状态码（200=成功，500=失败）
    private String message;    // 提示信息
    private T data;            // 泛型数据：根据业务场景动态指定
    private long timestamp;    // 时间戳

    // 静态工厂方法：快速创建成功响应（适配任意数据类型）
    public static <T> Result<T> success(T data) {
        return new Result<>(200, "操作成功", data, System.currentTimeMillis());
    }

    // 静态工厂方法：快速创建失败响应（无需数据）
    public static <T> Result<T> fail(String message) {
        return new Result<>(500, message, null, System.currentTimeMillis());
    }
}

// 使用场景1：返回User类型数据
User user = new User("admin", "123456");
Result<User> userResult = Result.success(user);

// 使用场景2：返回List<User>类型数据
List<User> userList = Arrays.asList(user);
Result<List<User>> listResult = Result.success(userList);

// 使用场景3：返回String类型数据
Result<String> stringResult = Result.success("操作完成");

（4）提升可读性：类型意图可视化，降低协作成本

泛型通过类型参数直接暴露“数据类型约束”，其他开发者无需查看内部逻辑，就能明确如何使用。例如：

// 一目了然：该List存储User对象
List<User> userList = new ArrayList<>();

// 一目了然：该Map的键是订单ID（Long），值是订单对象（Order）
Map<Long, Order> orderMap = new HashMap<>();

相比非泛型的List list = new ArrayList()，泛型写法的“类型意图”更清晰，尤其在团队协作中能大幅降低沟通成本。

1.2 泛型的底层实现：类型擦除

需要特别注意的是，Java泛型是“编译期特性”，在运行时会通过类型擦除（Type Erasure）将泛型信息清除，最终生成的字节码中不包含泛型参数。例如：

• List<String>和List<Integer>在运行时都会被擦除为List；
• 泛型类中的类型参数T会被擦除为Object（无界泛型）或上界类型（有界泛型）。

类型擦除的影响：

1. 无法在运行时判断泛型类型（如if (list instanceof List<String>)编译报错）；
2. 泛型数组创建受限（如new List<String>[10]编译报错，需用new List[10]）；
3. 静态方法不能使用类的泛型参数（因为静态方法属于类，泛型参数属于实例）。

理解类型擦除是掌握泛型的关键，很多泛型相关的“奇怪问题”（如通配符限制）都源于此。

二、泛型通配符详解：T、E、K、V与？的区别

在泛型中，T、E、K、V被称为“类型参数”（Type Parameter），?被称为“通配符”（Wildcard）。它们的核心区别在于：类型参数是“有名字的占位符”，通配符是“无名字的占位符”，且使用场景不同。

2.1 类型参数：T、E、K、V（有名字的占位符）

T、E、K、V本质上是“约定俗成的命名”，编译器并不强制区分（例如用X代替T也能编译），但遵循约定能提升代码可读性。它们的含义与适用场景如下：

类型参数	全称	含义	适用场景	源码案例
T	Type	任意类型（通用类型参数）	类、接口、方法的通用泛型，尤其适用于“单一类型约束”的场景	Result<T>（统一响应类）、Optional<T>（JDK工具类）
E	Element	集合中的元素类型	集合框架（如List、Set）、迭代器等与“元素”相关的泛型	List<E>、Set<E>、Iterator<E>
K	Key	映射中的键类型	键值对结构（如Map）中表示“键”的泛型	Map<K, V>、ConcurrentHashMap<K, V>
V	Value	映射中的值类型	键值对结构（如Map）中表示“值”的泛型	Map<K, V>、HashMap<K, V>

（1）T（Type）：通用类型参数

T是最常用的类型参数，代表“任意类型”，适用于大多数泛型场景，尤其是当泛型仅涉及“单一类型约束”时。

案例1：泛型类（如自定义缓存工具类）：

/**
 * 泛型缓存工具类：支持任意类型的缓存存储与获取
 * @param <T> 缓存数据的类型
 */
public class CacheUtils<T> {
    private Map<String, T> cacheMap = new ConcurrentHashMap<>();

    // 存储缓存：key为缓存键，value为泛型类型的缓存值
    public void put(String key, T value) {
        cacheMap.put(key, value);
    }

    // 获取缓存：返回泛型类型，无需强制转换
    public T get(String key) {
        return cacheMap.get(key);
    }

    // 清除缓存
    public void remove(String key) {
        cacheMap.remove(key);
    }
}

// 使用：存储User类型的缓存
CacheUtils<User> userCache = new CacheUtils<>();
userCache.put("admin", new User("admin", "123456"));
User admin = userCache.get("admin");  // 直接获取User类型

// 使用：存储List<String>类型的缓存
CacheUtils<List<String>> listCache = new CacheUtils<>();
listCache.put("tags", Arrays.asList("Java", "泛型", "面试"));
List<String> tags = listCache.get("tags");  // 直接获取List<String>类型

案例2：泛型方法（如通用数据转换方法）：

/**
 * 泛型工具类：提供通用数据转换方法
 */
public class ConvertUtils {
    /**
     * 将JSON字符串转换为指定类型的对象（泛型方法）
     * @param json JSON字符串
     * @param clazz 目标类型的Class对象（用于类型擦除后的反射实例化）
     * @param <T> 目标类型
     * @return 转换后的对象
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        try {
            // 使用Jackson进行JSON转换（实际项目中需引入依赖）
            ObjectMapper objectMapper = new ObjectMapper();
            return objectMapper.readValue(json, clazz);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON转换失败", e);
        }
    }
}

// 使用：将JSON转换为User对象
String userJson = "{\"username\":\"admin\",\"password\":\"123456\"}";
User user = ConvertUtils.fromJson(userJson, User.class);  // 直接获取User类型

// 使用：将JSON转换为Order对象
String orderJson = "{\"orderId\":1,\"amount\":99.9}";
Order order = ConvertUtils.fromJson(orderJson, Order.class);  // 直接获取Order类型

（2）E（Element）：集合元素类型

E专门用于“集合中的元素”，是集合框架的标准命名。例如List<E>、Set<E>、Queue<E>等，通过E明确表示“该泛型是集合存储的元素类型”。

源码案例：JDK中的List接口：

// JDK源码中的List接口（部分代码）
public interface List<E> extends Collection<E> {
    // 添加元素：参数类型为E（集合元素类型）
    boolean add(E e);

    // 获取元素：返回类型为E（集合元素类型）
    E get(int index);

    // 迭代器：返回Iterator<E>，迭代的元素类型为E
    Iterator<E> iterator();
}

// 使用：明确List存储的是String类型的元素
List<String> stringList = new ArrayList<>();
stringList.add("Java");  // 只能添加String类型
String str = stringList.get(0);  // 直接获取String类型

（3）K（Key）与V（Value）：键值对类型

K和V是“成对出现”的类型参数，专门用于键值对结构（如Map），分别代表“键”（Key）和“值”（Value）的类型。

源码案例：JDK中的Map接口：

// JDK源码中的Map接口（部分代码）
public interface Map<K, V> {
    // 存入键值对：K为键类型，V为值类型
    V put(K key, V value);

    // 根据键获取值：参数为K，返回为V
    V get(Object key);

    // 键集合：返回Set<K>，存储所有键
    Set<K> keySet();

    // 值集合：返回Collection<V>，存储所有值
    Collection<V> values();
}

// 使用：明确Map的键是Long（订单ID），值是Order（订单对象）
Map<Long, Order> orderMap = new HashMap<>();
orderMap.put(1L, new Order(1L, 99.9));  // 键必须是Long，值必须是Order
Order order = orderMap.get(1L);  // 直接获取Order类型

2.2 通配符？：无名字的占位符

?（通配符）代表“未知类型”，与T、E等类型参数的核心区别在于：

• 类型参数（T）：是“有名字的占位符”，可以在泛型类/方法中重复使用（如T fromJson(String json, Class<T> clazz)中T出现两次）；
• 通配符（?）：是“无名字的占位符”，只能使用一次，无法在多个地方关联（如List<?>中的?无法与其他?关联）。

根据约束范围，通配符分为三类：无界通配符<?>、上界通配符<? extends T>、下界通配符<? super T>。

（1）无界通配符<?>：接收任意类型

<?>表示“未知类型”，可以接收任意类型的泛型实例，但对该实例的操作会受到严格限制：

• 读取：只能读取到Object类型（因为未知具体类型，只能用最顶层的Object接收）；
• 写入：只能写入null（因为无法确定具体类型，写入任何非null值都可能导致类型不匹配）。

适用场景：仅需要“读取元素”且不关心元素具体类型的场景（如日志打印、元素计数）。

案例：通用日志打印工具：

/**
 * 无界通配符示例：打印任意类型List的元素
 * @param list 任意类型的List（List<String>、List<User>等均可）
 */
public static void printList(List<?> list) {
    System.out.println("List元素数量：" + list.size());
    // 读取：只能用Object接收（因为未知具体类型）
    for (Object obj : list) {
        System.out.println("元素：" + obj.toString());
    }

    // 写入限制：
    // list.add("test");  // 编译报错：无法确定list的具体类型，不能写入String
    // list.add(new User());  // 编译报错：无法确定list的具体类型，不能写入User
    list.add(null);  // 唯一允许的写入操作（null是所有类型的子类）
}

// 使用：打印List<String>
List<String> stringList = Arrays.asList("A", "B", "C");
printList(stringList);  // 合法，输出元素：A、B、C

// 使用：打印List<User>
List<User> userList = Arrays.asList(new User("admin", "123456"));
printList(userList);  // 合法，输出元素：User(username=admin, password=123456)

// 使用：打印List<Integer>
List<Integer> integerList = Arrays.asList(1, 2, 3);
printList(integerList);  // 合法，输出元素：1、2、3

（2）上界通配符<? extends T>：限制为T或其子类

<? extends T>表示“未知类型，但必须是T或T的子类”，也称为“生产者通配符”（Producer Wildcard）——因为该泛型实例主要用于“提供数据”（读取），而非“消费数据”（写入）。

核心特性：

• 读取：可以安全地读取到T类型（因为元素是T的子类，向上转型为T安全）；
• 写入：禁止写入任何非null值（因为无法确定具体是T的哪个子类，写入可能导致类型不匹配）。

适用场景：需要“读取泛型实例中的数据”，且数据类型是某个父类的子类（如读取“动物列表”，包含狗、猫、老虎等）。

案例：处理动物列表（生产者场景）：

// 定义动物类及其子类
class Animal {
    void eat() {
        System.out.println("动物进食");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("狗吃骨头");
    }
}

class Cat extends Animal {
    @Override
    void eat() {
        System.out.println("猫吃鱼");
    }
}

/**
 * 上界通配符示例：处理任意“动物子类”的列表（如Dog、Cat）
 * @param animalList 元素是Animal或其子类的List
 */
public static void feedAnimals(List<? extends Animal> animalList) {
    // 读取：安全转型为Animal（所有子类都能向上转型为父类）
    for (Animal animal : animalList) {
        animal.eat();  // 多态生效，调用子类的eat方法
    }

    // 写入限制：
    // animalList.add(new Dog());  // 编译报错：无法确定animalList是Dog还是Cat的List
    // animalList.add(new Animal());  // 编译报错：Animal不是Animal的子类（上界是extends，不包含父类）
    animalList.add(null);  // 唯一允许的写入操作
}

// 使用：传入Dog列表
List<Dog> dogList = Arrays.asList(new Dog());
feedAnimals(dogList);  // 输出：狗吃骨头（合法）

// 使用：传入Cat列表
List<Cat> catList = Arrays.asList(new Cat());
feedAnimals(catList);  // 输出：猫吃鱼（合法）

// 使用：传入Animal列表
List<Animal> animalList = Arrays.asList(new Animal(), new Dog());
feedAnimals(animalList);  // 输出：动物进食、狗吃骨头（合法）

源码案例：JDK中的Collections.max方法：
JDK的Collections.max方法使用上界通配符，支持获取任意“可比较对象”的最大值：

// JDK源码中的Collections.max方法
public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll) {
    // 逻辑：遍历集合，找到最大元素
}

// 使用：获取List<Integer>的最大值（Integer实现了Comparable）
List<Integer> intList = Arrays.asList(1, 3, 2);
Integer maxInt = Collections.max(intList);  // 结果：3

// 使用：获取List<String>的最大值（String实现了Comparable）
List<String> strList = Arrays.asList("A", "C", "B");
String maxStr = Collections.max(strList);  // 结果：C

（3）下界通配符<? super T>：限制为T或其父类

<? super T>表示“未知类型，但必须是T或T的父类”，也称为“消费者通配符”（Consumer Wildcard）——因为该泛型实例主要用于“消费数据”（写入），而非“提供数据”（读取）。

核心特性：

• 写入：可以安全地写入T或T的子类（因为父类集合可以存储子类对象，符合“里氏替换原则”）；
• 读取：只能读取到Object类型（因为未知具体是T的哪个父类，无法安全转型为T）。

适用场景：需要“向泛型实例中写入数据”，且数据类型是某个子类的父类（如向“动物列表”中添加狗、猫，向“对象列表”中添加动物）。

案例：添加宠物到列表（消费者场景）：

/**
 * 下界通配符示例：向任意“宠物父类”的列表中添加Dog
 * @param petList 元素是Dog或Dog父类的List（如Animal、Object）
 */
public static void addDog(List<? super Dog> petList) {
    // 写入：安全添加Dog或Dog的子类（Husky是Dog的子类）
    petList.add(new Dog());  // 合法：父类列表可以存储子类对象
    petList.add(new Husky());  // 合法：Husky是Dog的子类，也能存入父类列表

    // 写入限制：
    // petList.add(new Animal());  // 编译报错：Animal是Dog的父类，无法确定petList是否允许存储Animal
    // petList.add(new Object());  // 编译报错：Object是Dog的父类，无法确定petList是否允许存储Object

    // 读取：只能用Object接收（未知具体是Dog的哪个父类）
    Object obj = petList.get(0);
    if (obj instanceof Dog) {
        Dog dog = (Dog) obj;  // 需要强制转换，存在风险
    }
}

// 定义Husky类（Dog的子类）
class Husky extends Dog {
    @Override
    void eat() {
        System.out.println("哈士奇吃狗粮");
    }
}

// 使用：传入Dog列表（Dog是Dog的本身）
List<Dog> dogList = new ArrayList<>();
addDog(dogList);  // 列表中添加Dog和Husky（合法）

// 使用：传入Animal列表（Animal是Dog的父类）
List<Animal> animalList = new ArrayList<>();
addDog(animalList);  // 列表中添加Dog和Husky（合法）

// 使用：传入Object列表（Object是Dog的顶层父类）
List<Object> objectList = new ArrayList<>();
addDog(objectList);  // 列表中添加Dog和Husky（合法）

源码案例：JDK中的Collections.addAll方法：
JDK的Collections.addAll方法使用下界通配符，支持向任意“元素父类”的集合中添加元素：

// JDK源码中的Collections.addAll方法
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
    boolean modified = false;
    for (T e : elements) {
        if (c.add(e)) {  // 安全添加T类型元素（父类集合可以存储子类对象）
            modified = true;
        }
    }
    return modified;
}

// 使用：向List<Animal>中添加Dog（Animal是Dog的父类）
List<Animal> animalList = new ArrayList<>();
Collections.addAll(animalList, new Dog(), new Cat());  // 合法，添加Dog和Cat

// 使用：向List<Object>中添加String（Object是String的父类）
List<Object> objectList = new ArrayList<>();
Collections.addAll(objectList, "Java", "泛型");  // 合法，添加String

2.3 通配符与类型参数的选择原则

很多开发者在使用泛型时，会纠结“该用T还是?”。这里提供一个简单的选择原则：

• 用T（类型参数）的场景：需要在多个地方“关联同一类型”（如泛型类的字段与方法返回值、泛型方法的参数与返回值）；
• 用?（通配符）的场景：仅需要“单次使用未知类型”，且不需要关联其他地方的类型（如方法参数仅用于读取，不关心具体类型）。

对比案例：泛型方法 vs 通配符方法：

// 场景1：需要关联参数与返回值的类型（用T）
public static <T> T getFirstElement(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// 使用：参数是List<String>，返回值是String（类型关联）
String firstStr = getFirstElement(Arrays.asList("A", "B"));

// 场景2：仅读取，不关心具体类型（用?）
public static void printFirstElement(List<?> list) {
    Object firstObj = list.isEmpty() ? null : list.get(0);
    System.out.println("第一个元素：" + firstObj);
}

// 使用：参数可以是任意List，无需关联类型
printFirstElement(Arrays.asList("A", "B"));
printFirstElement(Arrays.asList(1, 2));

三、泛型实战：从框架到业务的典型应用

泛型不仅是基础语法，更是框架设计、业务开发的核心工具。以下是泛型在实际开发中的典型应用场景，结合代码案例帮助你灵活运用。

3.1 框架开发：通用DAO层设计

在MyBatis、Spring Data JPA等ORM框架中，泛型被广泛用于“通用DAO层”设计，避免为每个实体类编写重复的CRUD方法。

案例：基于Spring Data JPA的通用DAO：

// 1. 定义通用DAO接口（继承JpaRepository，使用泛型）
public interface BaseRepository<T, ID extends Serializable> extends JpaRepository<T, ID> {
    // 自定义通用方法：根据字段名和值查询
    Optional<T> findByField(String fieldName, Object value);
}

// 2. 实体类DAO接口（无需编写方法，直接继承通用DAO）
// User实体的DAO：T=User，ID=Long（用户ID类型）
public interface UserRepository extends BaseRepository<User, Long> {
    // 仅需定义User特有的查询方法（如根据用户名查询）
    Optional<User> findByUsername(String username);
}

// Order实体的DAO：T=Order，ID=Long（订单ID类型）
public interface OrderRepository extends BaseRepository<Order, Long> {
    // 仅需定义Order特有的查询方法（如根据用户ID查询）
    List<Order> findByUserId(Long userId);
}

// 3. 使用DAO（无需关注通用方法的实现，直接调用）
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        // 调用通用DAO的方法（findById由JpaRepository提供）
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("用户不存在"));
    }

    public User getUserByUsername(String username) {
        // 调用User特有的方法
        return userRepository.findByUsername(username)
                .orElseThrow(() -> new RuntimeException("用户不存在"));
    }
}

3.2 工具类开发：通用JSON转换工具

在项目中，JSON转换是高频操作，使用泛型可以编写“通用JSON工具类”，适配所有实体类型。

案例：基于Jackson的通用JSON工具：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 通用JSON工具类（泛型实现）
 */
public class JsonUtils {
    // 静态ObjectMapper（避免重复创建，提升性能）
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    /**
     * 将对象转换为JSON字符串
     * @param obj 任意类型的对象
     * @param <T> 对象类型
     * @return JSON字符串
     */
    public static <T> String toJson(T obj) {
        try {
            return OBJECT_MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("对象转JSON失败", e);
        }
    }

    /**
     * 将JSON字符串转换为指定类型的对象
     * @param json JSON字符串
     * @param clazz 目标类型的Class
     * @param <T> 目标类型
     * @return 转换后的对象
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON转对象失败", e);
        }
    }

    /**
     * 将JSON字符串转换为泛型集合（如List<User>、Map<String, Object>）
     * @param json JSON字符串
     * @param typeReference 泛型类型引用（解决类型擦除问题）
     * @param <T> 目标泛型类型
     * @return 转换后的泛型集合
     */
    public static <T> T fromJson(String json, com.fasterxml.jackson.core.type.TypeReference<T> typeReference) {
        try {
            return OBJECT_MAPPER.readValue(json, typeReference);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON转泛型集合失败", e);
        }
    }
}

// 使用1：对象转JSON
User user = new User("admin", "123456");
String userJson = JsonUtils.toJson(user);  // 结果：{"username":"admin","password":"123456"}

// 使用2：JSON转对象
User user2 = JsonUtils.fromJson(userJson, User.class);

// 使用3：JSON转泛型集合（如List<User>）
String userListJson = "[{\"username\":\"admin\",\"password\":\"123456\"},{\"username\":\"test\",\"password\":\"654321\"}]";
List<User> userList = JsonUtils.fromJson(userListJson, new com.fasterxml.jackson.core.type.TypeReference<List<User>>() {});

3.3 业务开发：泛型枚举与策略模式

在复杂业务中，泛型可以结合枚举、策略模式，实现“通用业务逻辑适配多场景”。例如，订单状态流转、支付方式处理等。

案例：泛型枚举实现支付方式策略：

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 支付方式枚举（泛型策略模式）
 * @param <T> 支付请求参数类型（不同支付方式的参数不同）
 */
@Getter
@AllArgsConstructor
public enum PaymentType<T> {
    // 支付宝支付：请求参数类型为AlipayRequest
    ALIPAY("支付宝", AlipayRequest.class) {
        @Override
        public String pay(T request) {
            // 强转为AlipayRequest（泛型擦除后需确认类型）
            AlipayRequest alipayRequest = (AlipayRequest) request;
            // 支付宝支付逻辑（调用支付宝API）
            return "支付宝支付成功，订单号：" + alipayRequest.getOrderId();
        }
    },

    // 微信支付：请求参数类型为WechatPayRequest
    WECHAT_PAY("微信支付", WechatPayRequest.class) {
        @Override
        public String pay(T request) {
            // 强转为WechatPayRequest
            WechatPayRequest wechatRequest = (WechatPayRequest) request;
            // 微信支付逻辑（调用微信API）
            return "微信支付成功，订单号：" + wechatRequest.getOrderId();
        }
    };

    private final String desc;          // 支付方式描述
    private final Class<T> requestClazz;// 支付请求参数类型

    /**
     * 抽象支付方法（由具体枚举实现）
     * @param request 支付请求参数（泛型类型）
     * @return 支付结果
     */
    public abstract String pay(T request);

    /**
     * 根据支付方式编码获取枚举（通用方法）
     * @param code 支付方式编码（如"ALIPAY"）
     * @return 支付方式枚举
     */
    public static PaymentType<?> getByCode(String code) {
        for (PaymentType<?> type : values()) {
            if (type.name().equals(code)) {
                return type;
            }
        }
        throw new RuntimeException("不支持的支付方式：" + code);
    }
}

// 支付宝支付请求参数
class AlipayRequest {
    private String orderId;
    private BigDecimal amount;
    // getter/setter
}

// 微信支付请求参数
class WechatPayRequest {
    private String orderId;
    private BigDecimal amount;
    private String openId;
    // getter/setter
}

// 业务使用：根据支付方式编码处理支付
public class PaymentService {
    public String processPayment(String paymentCode, Object request) {
        // 获取支付方式枚举
        PaymentType<?> paymentType = PaymentType.getByCode(paymentCode);

        // 校验请求参数类型（避免类型错误）
        if (!paymentType.getRequestClazz().isInstance(request)) {
            throw new RuntimeException("支付请求参数类型错误");
        }

        // 执行支付（泛型方法调用）
        return paymentType.pay(request);
    }
}

// 测试支付宝支付
PaymentService service = new PaymentService();
AlipayRequest alipayRequest = new AlipayRequest();
alipayRequest.setOrderId("123456");
alipayRequest.setAmount(new BigDecimal("99.9"));
String alipayResult = service.processPayment("ALIPAY", alipayRequest);
System.out.println(alipayResult);  // 输出：支付宝支付成功，订单号：123456

// 测试微信支付
WechatPayRequest wechatRequest = new WechatPayRequest();
wechatRequest.setOrderId("654321");
wechatRequest.setAmount(new BigDecimal("199.9"));
wechatRequest.setOpenId("o6_bmjrPTlm6_2sgVt7hMZOPfL2M");
String wechatResult = service.processPayment("WECHAT_PAY", wechatRequest);
System.out.println(wechatResult);  // 输出：微信支付成功，订单号：654321

四、泛型常见问题与避坑指南

在使用泛型时，很多开发者会遇到“编译报错”“运行时异常”等问题，这些问题大多与“类型擦除”“通配符限制”相关。以下是常见问题及解决方案：

4.1 问题1：无法创建泛型数组

现象：new List<String>[10]编译报错，提示“泛型数组创建不允许”。
原因：类型擦除后，List<String>和List<Integer>都会被擦除为List，泛型数组无法在运行时区分类型，可能导致ArrayStoreException。
解决方案：使用“泛型集合”代替“泛型数组”，或创建“原始类型数组”后强制转换（需谨慎）。

// 错误写法：无法创建泛型数组
// List<String>[] stringLists = new List<String>[10];  // 编译报错

// 正确写法1：使用List<List<String>>代替泛型数组
List<List<String>> stringListList = new ArrayList<>();
stringListList.add(Arrays.asList("A", "B"));
stringListList.add(Arrays.asList("C", "D"));

// 正确写法2：创建原始类型数组后强制转换（需确保类型安全）
List<String>[] stringLists = (List<String>[]) new List[10];
stringLists[0] = Arrays.asList("A", "B");  // 合法
// stringLists[1] = Arrays.asList(1, 2);  // 编译不报错，但运行时可能抛出异常（需避免）

4.2 问题2：无法在运行时判断泛型类型

现象：if (list instanceof List<String>)编译报错，提示“无法对参数化类型执行instanceof检查”。
原因：类型擦除后，运行时无法获取泛型参数信息，List<String>和List<Integer>在运行时都是List。
解决方案：

1. 若需判断元素类型，可遍历集合检查元素的Class；
2. 若需明确泛型类型，可通过“类型令牌”（Type Token）传递Class对象（如fromJson方法中的Class<T> clazz）。

// 错误写法：无法在运行时判断泛型类型
List<String> stringList = new ArrayList<>();
// if (stringList instanceof List<String>) {  // 编译报错
//     // 逻辑
// }

// 正确写法1：检查集合中元素的类型（适用于非空集合）
public static boolean isStringList(List<?> list) {
    if (list.isEmpty()) {
        throw new RuntimeException("集合为空，无法判断元素类型");
    }
    // 检查第一个元素是否为String类型
    return list.get(0) instanceof String;
}

// 正确写法2：使用类型令牌传递Class对象
public static <T> boolean isTypeMatch(List<?> list, Class<T> clazz) {
    if (list.isEmpty()) {
        return true;  // 空集合默认匹配（或根据业务调整）
    }
    // 检查第一个元素是否为指定类型
    return clazz.isInstance(list.get(0));
}

// 使用
List<String> stringList = Arrays.asList("A", "B");
boolean isString = isTypeMatch(stringList, String.class);  // 结果：true

List<Integer> intList = Arrays.asList(1, 2);
boolean isInt = isTypeMatch(intList, Integer.class);  // 结果：true

4.3 问题3：静态方法无法使用类的泛型参数

现象：在泛型类中，静态方法使用类的泛型参数T会编译报错，提示“无法从静态上下文中引用非静态类型变量T”。
原因：类的泛型参数T属于“实例级别的参数”，需要在创建对象时指定；而静态方法属于“类级别的方法”，在类加载时就已存在，无法引用实例级别的泛型参数。
解决方案：将静态方法定义为“泛型方法”，使用独立的泛型参数（如static <T> T method(...)）。

// 错误写法：静态方法使用类的泛型参数
class GenericClass<T> {
    // public static T getInstance() {  // 编译报错：无法从静态上下文中引用非静态类型变量T
    //     return null;
    // }
}

// 正确写法：静态方法定义为泛型方法
class GenericClass<T> {
    // 静态泛型方法：使用独立的泛型参数S（与类的T无关）
    public static <S> S getInstance(Class<S> clazz) {
        try {
            return clazz.newInstance();  // 通过反射创建实例
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException("创建实例失败", e);
        }
    }
}

// 使用：获取User实例
User user = GenericClass.getInstance(User.class);

// 使用：获取Order实例
Order order = GenericClass.getInstance(Order.class);

五、总结：泛型学习的3个阶段

掌握泛型不是一蹴而就的，需要经历“使用→理解→灵活运用”三个阶段：

1. 第一阶段：会用：能正确使用List<String>、Map<K, V>等基础泛型，避免类型转换错误；
2. 第二阶段：理解：明白类型擦除的原理，掌握T、E、K、V与?的区别，能根据场景选择合适的通配符；
3. 第三阶段：灵活运用：在框架设计、工具类开发中主动使用泛型，实现代码复用与类型安全。

泛型作为Java的核心特性，是从“初级开发者”到“中级开发者”的重要分水岭。希望本文能帮助你跳出“只会用不会懂”的困境，真正将泛型融入到日常开发中，写出更优雅、更安全、更易维护的代码。

除非注明，否则均为李锋镝的博客原创文章，转载必须以链接形式标明本文链接

本文链接：https://www.lifengdi.com/hou-duan/4522