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

  // 非泛型写法（存在类型转换风险）
  List list1 = new ArrayList();
  list1.add("a");
  Integer num = (Long) list1.get(0);  // 运行时抛出 ClassCastException

  // 泛型写法（编译时检查类型）
  List<String> list2 = new ArrayList<>();
  // list.add(1);       // 编译报错
  list2.add("a");
  String str = list2.get(0); // 无需强制转换 

// 非泛型写法
Map map1 = new HashMap();
map1.put("user", new User());
User user1 = (User) map1.get("user");

// 泛型写法
Map<String, User> map2 = new HashMap<>();
map2.put("user", new User());
// 自动转换
User user2 = map2.get("user");

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
    /**
     * 响应状态码
     */
    private int code;

    /**
     * 响应信息
     */
    private String message;

    /**
     * 响应数据
     */
    private T data;

    /**
     * 时间戳
     */
    private long timestamp;
    其他代码省略...

List<String> list = new ArrayList<>();

pubile class A<T>{
    prvate T t;
    //其他省略...
}

//创建一个不带泛型参数的A
    A a = new A();
    a.set(new B());
    B b = (B) a.get();//需要进行强制类型转换

//创建一个带泛型参数的A
    A<B> a = new A<B>();
    a.set(new B());
    B b = a.get();

List<E> list = new ArrayList<>();

Map<K,V> map = new HashMap<>();

Map<K,V> map = new HashMap<>();

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

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

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

import java.util.ArrayList;
import java.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);       // 唯一允许的写入操作
    }

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

    /**
     * 下界通配符 <? super T>
     */ 
    // 安全写入Dog，读取需要强制转换（消费者场景）
    public static void addDogs(List<? super Dog> 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<String> strings = List.of("A", "B", "C");
        printAllElements(strings);

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

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

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

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

        List<Object> objects = new ArrayList<>();
        addDogs(objects);
    }
}