Java泛型中通配符T、E、K、V、？的深入理解

2. E（Element） —— 专门表示集合中的元素类型，比如List。

List list = new ArrayList<>();

3. K（Key） —— 表示映射（Map）中键的数据类型。

Map map = new HashMap<>();

4. V（Value） —— 表示映射中值的数据类型。

Map map = new HashMap<>();

需要说明的是，这些只是开发中的命名约定，并非强制规则。但遵循这些惯例能让代码更易读，团队成员一看便知意图。

通配符 ?

问号通配符比前面几个稍微复杂一些，它有三种变体：无界、上界、下界。

1. 无界通配符 —— 表示未知类型，可以接收任意类型的集合，通常用在只读场景。

   // 使用无界通配符处理任意类型的查询结果
   public void logQueryResult(List resultList) {
       resultList.forEach(obj -> log.info("Result: {}", obj));
   }

2. 上界通配符 —— 表示类型是T或T的子类，适合“生产者”场景（只往外读，不往里写）。

 // 使用上界通配符读取缓存
   public  T getCache(String key, Class clazz) {
       Object value = redisTemplate.opsForValue().get(key);
       return clazz.cast(value);
   }

3. 下界通配符 —— 表示类型是T或T的父类，适合“消费者”场景（往里写数据，读出来只能当Object处理）。

  // 使用下界通配符写入缓存
   public void setCache(String key,  value) {
       redisTemplate.opsForValue().set(key, value);
   }

下面是一个综合示例，把三种通配符放一起演示，能更直观地理解各自的行为差异：

import ja va.util.ArrayList;
import ja va.util.List;

public class Demo {
    //实体类
    class Animal {
        void eat() {
            System.out.println("Animal is eating");
        }
    }

    class Dog extends Animal {
        @Override
        void eat() {
            System.out.println("Dog is eating");
        }
    }

    class Husky extends Dog {
        @Override
        void eat() {
            System.out.println("Husky is eating");
        }
    }

    /**
     * 无界通配符 
     */
    // 只能读取元素，不能写入（除null外）
    public static void printAllElements(List list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
        // list.add("test");  // 编译错误！无法写入具体类型
        list.add(null);       // 唯一允许的写入操作
    }

    /**
     * 上界通配符 
     */ 
    // 安全读取为Animal，但不能写入（生产者场景）
    public static void processAnimals(List animals) {
        for (Animal animal : animals) {
            animal.eat();
        }
        // animals.add(new Dog());  // 编译错误！无法确定具体子类型
    }

    /**
     * 下界通配符 
     */ 
    // 安全写入Dog，读取需要强制转换（消费者场景）
    public static void addDogs(List dogList) {
        dogList.add(new Dog());
        dogList.add(new Husky()); // Husky是Dog子类
        // dogList.add(new Animal()); // 编译错误！Animal不是Dog的超类
        
        Object obj = dogList.get(0); // 读取只能为Object
        if (obj instanceof Dog) {
            Dog dog = (Dog) obj;     // 需要显式类型转换
        }
    }

    public static void main(String[] args) {
        // 测试无界通配符
        List strings = List.of("A", "B", "C");
        printAllElements(strings);

        List integers = List.of(1, 2, 3);
        printAllElements(integers);

        // 测试上界通配符
        List dogs = new ArrayList<>();
        dogs.add(new Dog());
        processAnimals(dogs);

        List huskies = new ArrayList<>();
        huskies.add(new Husky());
        processAnimals(huskies);

        // 测试下界通配符
        List animals = new ArrayList<>();
        addDogs(animals);
        System.out.println(animals);

        List