泛型 ⭐⭐

// ========== 没有泛型的旧时代 ==========
List list = new ArrayList();       // 原始类型 Raw Type
list.add("Hello");                  // 放入 String
list.add(42);                       // 放入 Integer —— 编译器不报错！
String s = (String) list.get(1);    // 运行时 ClassCastException 💥
 
// ========== 有泛型的新时代 ==========
List<String> safeList = new ArrayList<>();  // 参数化类型
safeList.add("Hello");                       // ✅ 合法
// safeList.add(42);                         // ❌ 编译期直接报错，问题扼杀在摇篮里
String s2 = safeList.get(0);                 // 无需强转，编译器自动推断

// 单类型参数
public class Box<T> { }
 
// 多类型参数
public class Pair<K, V> { }
 
// 三个类型参数
public class Triple<A, B, C> { }

// T 是类型参数（Type Parameter）—— 定义时的"形参"
public class Box<T> {
    private T value;
}
 
// String 是类型实参（Type Argument）—— 使用时的"实参"
Box<String> stringBox = new Box<>();

// JDK 5/6 的写法 —— 右侧必须显式写出类型实参
Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();
 
// JDK 7+ 的写法 —— 钻石操作符，编译器自动推断
Map<String, List<Integer>> map = new HashMap<>();  // 清爽多了

/**
 * 一个泛型容器类
 * T 是类型参数，在实例化时由调用者指定具体类型
 */
public class Box<T> {
 
    // T 可以作为成员变量的类型
    private T content;
 
    // T 可以作为构造方法的参数类型
    public Box(T content) {
        this.content = content;
    }
 
    // T 可以作为方法的返回类型
    public T getContent() {
        return content;
    }
 
    // T 可以作为方法的参数类型
    public void setContent(T content) {
        this.content = content;
    }
 
    @Override
    public String toString() {
        // 运行时可以通过实例获取实际类型信息
        return "Box{content=" + content +
               ", type=" + (content != null ? content.getClass().getSimpleName() : "null") + "}";
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        // 创建一个装 String 的盒子
        Box<String> stringBox = new Box<>("Hello Generics");
        String s = stringBox.getContent();   // 无需强转，编译器保证类型安全
        System.out.println(stringBox);        // Box{content=Hello Generics, type=String}
 
        // 创建一个装 Integer 的盒子
        Box<Integer> intBox = new Box<>(42);
        int num = intBox.getContent();        // 自动拆箱，也无需强转
        System.out.println(intBox);           // Box{content=42, type=Integer}
 
        // 创建一个装自定义对象的盒子
        Box<List<String>> listBox = new Box<>(Arrays.asList("A", "B", "C"));
        List<String> list = listBox.getContent();  // 嵌套泛型也完全没问题
    }
}

/**
 * 泛型键值对
 * K —— 键的类型
 * V —— 值的类型
 */
public class Pair<K, V> {
 
    private final K key;    // 键，类型由 K 决定
    private final V value;  // 值，类型由 V 决定
 
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() {
        return key;
    }
 
    public V getValue() {
        return value;
    }
 
    @Override
    public String toString() {
        return "(" + key + " -> " + value + ")";
    }
}

public class PairDemo {
    public static void main(String[] args) {
        // K=String, V=Integer
        Pair<String, Integer> score = new Pair<>("Math", 95);
        String subject = score.getKey();     // 编译器知道 key 是 String
        int point = score.getValue();         // 编译器知道 value 是 Integer
 
        // K=Integer, V=List<String>  —— 类型实参可以是任意复杂的类型
        Pair<Integer, List<String>> group = new Pair<>(1, Arrays.asList("Alice", "Bob"));
    }
}

// 情况1：子类保留父类的所有类型参数，并可以添加自己的
public class SpecialBox<T, U> extends Box<T> {
    private U extra;  // 子类新增的类型参数
    public SpecialBox(T content, U extra) {
        super(content);
        this.extra = extra;
    }
}
 
// 情况2：子类指定父类的类型参数为具体类型
public class StringBox extends Box<String> {
    public StringBox(String content) {
        super(content);  // 父类的 T 被固定为 String
    }
}
 
// 情况3：子类不传类型参数（Raw Type，不推荐）
// 编译器会发出 unchecked 警告
public class RawBox extends Box {  // ⚠️ 丢失了类型安全
    public RawBox(Object content) {
        super(content);
    }
}

//  修饰符   类型参数声明   返回类型   方法名
//    ↓         ↓           ↓        ↓
public static  <T>          T       getFirst(List<T> list) { ... }

public class GenericMethodDemo {
 
    /**
     * 泛型方法：交换数组中两个位置的元素
     * <T> 声明在 static 和 void 之间，表示这是一个泛型方法
     * T 的实际类型由调用时传入的数组类型决定
     */
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];    // temp 的类型跟随 T
        array[i] = array[j];  // 类型安全的交换
        array[j] = temp;
    }
 
    /**
     * 泛型方法：将任意类型的数组转为 List
     * 使用 @SafeVarargs 抑制可变参数的泛型警告
     */
    @SafeVarargs
    public static <T> List<T> toList(T... elements) {
        List<T> list = new ArrayList<>();  // 创建对应类型的 List
        for (T element : elements) {       // 遍历可变参数
            list.add(element);             // 逐个添加
        }
        return list;                       // 返回类型为 List<T>
    }
 
    /**
     * 多类型参数的泛型方法
     * K 和 V 是方法自己的类型参数，与类无关
     */
    public static <K, V> Map<K, V> mapOf(K key, V value) {
        Map<K, V> map = new HashMap<>();   // 创建 Map
        map.put(key, value);               // 放入键值对
        return map;                        // 返回参数化的 Map
    }
 
    public static void main(String[] args) {
        // 调用泛型方法 —— 编译器自动推断 T 为 String
        String[] names = {"Alice", "Bob", "Charlie"};
        swap(names, 0, 2);  // T 被推断为 String
        System.out.println(Arrays.toString(names));  // [Charlie, Bob, Alice]
 
        // 调用泛型方法 —— 编译器自动推断 T 为 Integer
        Integer[] nums = {1, 2, 3};
        swap(nums, 0, 1);   // T 被推断为 Integer
        System.out.println(Arrays.toString(nums));   // [2, 1, 3]
 
        // 也可以显式指定类型参数（通常不需要，但语法上支持）
        GenericMethodDemo.<String>swap(names, 0, 1);
 
        // toList 方法的调用
        List<String> nameList = toList("X", "Y", "Z");  // T 推断为 String
        List<Integer> numList = toList(1, 2, 3);          // T 推断为 Integer
 
        // 多类型参数
        Map<String, Integer> map = mapOf("age", 25);  // K=String, V=Integer
    }
}

public class Box<T> {
 
    private T content;
 
    // 这不是泛型方法！这只是使用了类的类型参数 T 的普通方法
    public T getContent() {
        return content;
    }
 
    // 这不是泛型方法！参数类型 T 来自类的声明
    public void setContent(T content) {
        this.content = content;
    }
 
    // 这才是泛型方法！它声明了自己的类型参数 <U>
    // U 与类的 T 完全独立
    public <U> void inspect(U item) {
        System.out.println("T 的类型: " + content.getClass().getSimpleName());
        System.out.println("U 的类型: " + item.getClass().getSimpleName());
    }
 
    // 这也是泛型方法，同时使用了类的 T 和方法自己的 R
    public <R> Pair<T, R> pairWith(R other) {
        return new Pair<>(this.content, other);
    }
}

public class MethodVsGenericMethod {
    public static void main(String[] args) {
        Box<String> box = new Box<>("Hello");
 
        // getContent() 返回 String —— 类型来自类的 T=String
        String s = box.getContent();
 
        // inspect() 是泛型方法，U 独立推断为 Double
        box.inspect(3.14);
        // 输出:
        // T 的类型: String
        // U 的类型: Double
 
        // pairWith() 同时使用 T=String 和 R=Integer
        Pair<String, Integer> pair = box.pairWith(100);
    }
}

// 编译器根据参数 "Hello" 推断 T = String
String first = getFirst(Arrays.asList("Hello", "World"));
 
// 编译器根据赋值目标 List<Double> 推断 T = Double
List<Double> doubles = toList(1.0, 2.0, 3.0);
 
// 当推断有歧义时，可以显式指定
// 例如 Collections 的 emptyList()
List<String> empty = Collections.<String>emptyList();

/**
 * 自定义泛型接口：数据转换器
 * 将 F（From）类型转换为 T（To）类型
 */
public interface Converter<F, T> {
 
    // 接口方法使用类型参数
    T convert(F source);
}

// 策略1：实现时指定具体类型 —— 最常见
public class StringToIntConverter implements Converter<String, Integer> {
    @Override
    public Integer convert(String source) {
        return Integer.parseInt(source);  // String -> Integer
    }
}
 
// 策略2：实现类本身也是泛型，保留接口的类型参数
public class ListConverter<F, T> implements Converter<List<F>, List<T>> {
    private final Converter<F, T> elementConverter;  // 单元素转换器
 
    public ListConverter(Converter<F, T> elementConverter) {
        this.elementConverter = elementConverter;
    }
 
    @Override
    public List<T> convert(List<F> source) {
        List<T> result = new ArrayList<>();       // 创建结果列表
        for (F item : source) {                   // 遍历源列表
            result.add(elementConverter.convert(item));  // 逐个转换
        }
        return result;
    }
}
 
// 策略3：部分指定 —— 固定一个，保留一个
public class JsonDeserializer<T> implements Converter<String, T> {
    // F 被固定为 String（JSON 字符串），T 保留为泛型
    @Override
    public T convert(String json) {
        // 反序列化逻辑...
        return null;
    }
}

/**
 * 实现 Comparable<T> 接口，使 Student 对象可以自然排序
 * T 被指定为 Student 自身 —— 这是一种常见的模式
 */
public class Student implements Comparable<Student> {
 
    private String name;   // 学生姓名
    private int score;     // 学生分数
 
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
 
    /**
     * 实现 compareTo 方法
     * 参数类型是 Student 而不是 Object —— 这就是泛型的好处
     * 无需强制转换，类型安全
     */
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.score, other.score);  // 按分数升序
    }
 
    @Override
    public String toString() {
        return name + ":" + score;
    }
}

public class ComparableDemo {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 88),
            new Student("Bob", 95),
            new Student("Charlie", 72)
        );
 
        Collections.sort(students);  // 自然排序，调用 compareTo
        System.out.println(students); // [Charlie:72, Alice:88, Bob:95]
    }
}

public class FunctionalGenericDemo {
    public static void main(String[] args) {
 
        // Converter 接口只有一个抽象方法，天然就是函数式接口
        // 可以用 Lambda 表达式实现
        Converter<String, Integer> strToInt = source -> Integer.parseInt(source);
        // 甚至可以用方法引用
        Converter<String, Integer> strToInt2 = Integer::parseInt;
 
        Integer result = strToInt.convert("123");  // 123
        System.out.println(result);
 
        // Java 标准库的函数式泛型接口
        // Function<T, R>：接收 T，返回 R
        Function<String, Integer> lengthFunc = String::length;
        int len = lengthFunc.apply("Hello");  // 5
 
        // Predicate<T>：接收 T，返回 boolean
        Predicate<String> isLong = s -> s.length() > 10;
        boolean test = isLong.test("Short");  // false
 
        // Consumer<T>：接收 T，无返回值
        Consumer<String> printer = System.out::println;
        printer.accept("Printed by Consumer");
 
        // Supplier<T>：无参数，返回 T
        Supplier<List<String>> listFactory = ArrayList::new;
        List<String> newList = listFactory.get();  // 得到一个新的空 ArrayList
    }
}

public class Quiz<T> {
    // 方法 A
    public T methodA(T param) {
        return param;
    }
 
    // 方法 B
    public <U> void methodB(U param) {
        System.out.println(param);
    }
 
    // 方法 C
    public void methodC(Object param) {
        System.out.println(param);
    }
 
    // 方法 D
    public T methodD() {
        return null;
    }
}

// T 必须是 Number 或 Number 的子类（Integer, Double, Long...）
public class Box<T extends Number> {
    private T value;
 
    public Box(T value) {
        this.value = value;
    }
 
    // 因为编译器知道 T 至少是 Number，所以可以安全调用 Number 的方法
    public double toDouble() {
        return value.doubleValue(); // ✅ 编译通过，Number 有 doubleValue()
    }
}

// ✅ Integer extends Number，合法
Box<Integer> intBox = new Box<>(42);
 
// ✅ Double extends Number，合法
Box<Double> doubleBox = new Box<>(3.14);
 
// ❌ 编译错误！String 不是 Number 的子类
// Box<String> strBox = new Box<>("hello");

public class MathUtils {
 
    // T 必须实现 Comparable 接口，才能进行比较
    public static <T extends Comparable<T>> T findMax(T[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("数组不能为空"); // 防御性检查
        }
 
        T max = array[0]; // 假设第一个元素是最大值
 
        for (int i = 1; i < array.length; i++) {
            // compareTo() 来自 Comparable 接口
            // 返回正数表示 array[i] > max
            if (array[i].compareTo(max) > 0) {
                max = array[i]; // 更新最大值
            }
        }
 
        return max; // 返回最大值
    }
}

// 使用示例
Integer[] nums = {3, 7, 1, 9, 4};
System.out.println(MathUtils.findMax(nums)); // 输出: 9
 
String[] words = {"apple", "orange", "banana"};
System.out.println(MathUtils.findMax(words)); // 输出: orange（按字典序）

// 约束到类 → 用 extends
<T extends Number>
 
// 约束到接口 → 还是用 extends（不是 implements！）
<T extends Comparable<T>>
 
// 这是语法规定，没有为什么，记住就好

// T 必须同时满足：继承 Number 且实现 Comparable 接口
public static <T extends Number & Comparable<T>> T findMaxNumber(T[] array) {
    T max = array[0]; // 初始化最大值
 
    for (int i = 1; i < array.length; i++) {
        if (array[i].compareTo(max) > 0) { // Comparable 提供的能力
            max = array[i];
        }
    }
 
    // Number 提供的能力：可以转换为 double 输出
    System.out.println("最大值的 double 形式: " + max.doubleValue());
    return max;
}

// ✅ 正确：类在前，接口在后
<T extends SomeClass & InterfaceA & InterfaceB>
 
// ❌ 编译错误：接口不能放在类前面
// <T extends InterfaceA & SomeClass>
 
// ❌ 编译错误：最多只能有一个类（Java 单继承）
// <T extends ClassA & ClassB>

// 定义一个有上界约束的泛型接口
public interface Calculator<T extends Number> {
    T add(T a, T b);       // 加法
    double average(T[] values); // 求平均值
}
 
// 实现类指定具体类型 Integer（Integer extends Number ✅）
public class IntCalculator implements Calculator<Integer> {
 
    @Override
    public Integer add(Integer a, Integer b) {
        return a + b; // 自动拆箱 + 装箱
    }
 
    @Override
    public double average(Integer[] values) {
        int sum = 0;                          // 累加器
        for (Integer val : values) {
            sum += val;                       // 累加每个元素
        }
        return (double) sum / values.length;  // 强转为 double 再除
    }
}

// 泛型基类：约束 VM 必须是 ViewModel 的子类
public abstract class BaseActivity<VM extends ViewModel> extends AppCompatActivity {
 
    protected VM viewModel; // 子类可以直接使用具体类型的 ViewModel
 
    // 抽象方法，由子类提供 ViewModel 的 Class 对象
    protected abstract Class<VM> getViewModelClass();
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 利用约束，安全地创建 ViewModel 实例
        viewModel = new ViewModelProvider(this).get(getViewModelClass());
    }
}
 
// 具体子类：指定 VM = LoginViewModel
public class LoginActivity extends BaseActivity<LoginViewModel> {
 
    @Override
    protected Class<LoginViewModel> getViewModelClass() {
        return LoginViewModel.class; // 返回具体的 Class 对象
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // viewModel 的类型已经是 LoginViewModel，无需强转
        viewModel.login("user", "pass"); // ✅ 直接调用子类方法
    }
}

// Comparable 的定义本身就是递归类型约束
public interface Comparable<T> {
    int compareTo(T o);
}
 
// 当我们写 class Student implements Comparable<Student> 时
// 意味着 Student 只能和 Student 比较，不能和其他类型比较
public class Student implements Comparable<Student> {
    private String name;  // 学生姓名
    private int score;    // 学生分数
 
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
 
    @Override
    public int compareTo(Student other) {
        // 按分数降序排列
        return Integer.compare(other.score, this.score);
    }
 
    @Override
    public String toString() {
        return name + "(" + score + ")";
    }
}

// 经典的递归类型约束应用：取集合中的最大值
public static <T extends Comparable<T>> T max(Collection<T> collection) {
    Iterator<T> iterator = collection.iterator(); // 获取迭代器
    T largest = iterator.next();                  // 取第一个元素作为初始最大值
 
    while (iterator.hasNext()) {
        T next = iterator.next();                 // 取下一个元素
        if (next.compareTo(largest) > 0) {        // 与当前最大值比较
            largest = next;                       // 更新最大值
        }
    }
 
    return largest;
}

// 无约束：擦除后 T → Object
public class Box<T> {
    private T value;
    // 编译后变成: private Object value;
}
 
// 有约束：擦除后 T → Number（上界类型）
public class NumberBox<T extends Number> {
    private T value;
    // 编译后变成: private Number value;
}
 
// 多重约束：擦除后 T → 第一个约束类型
public class MultiBox<T extends Number & Comparable<T>> {
    private T value;
    // 编译后变成: private Number value;（取第一个约束）
}

// 误区 1：约束中不能使用基本类型
// ❌ 编译错误：int 不是引用类型
// public class Box<T extends int> {}
 
// ✅ 正确：使用包装类
public class Box<T extends Integer> {}
 
 
// 误区 2：静态上下文中不能使用类的类型参数
public class Container<T extends Number> {
    // ❌ 编译错误：静态方法不能引用类级别的类型参数 T
    // public static T getDefault() { return null; }
 
    // ✅ 正确：静态方法需要声明自己的类型参数
    public static <E extends Number> E getDefault(Class<E> clazz) {
        return null;
    }
}
 
 
// 误区 3：不能用 instanceof 检查泛型类型
public <T extends Number> void check(Object obj) {
    // ❌ 编译错误：运行时泛型信息已被擦除
    // if (obj instanceof T) {}
 
    // ✅ 正确：通过 Class 对象检查
    // if (Number.class.isInstance(obj)) {}
}

// 打印任意类型 List 的信息 —— 典型的无界通配符用法
public static void printListInfo(List<?> list) {
    // 可以调用 size()，这与元素类型无关
    System.out.println("Size: " + list.size());
 
    // 可以遍历并打印，因为每个元素至少是 Object
    for (Object item : list) {
        // 取出的元素类型是 Object，这是编译器能保证的最大范围
        System.out.println("  Element: " + item);
    }
 
    // ❌ 编译错误！不能往 List<?> 中添加任何元素（null 除外）
    // list.add("hello");  // 因为编译器不知道 ? 到底是什么类型
    // list.add(123);      // 同理，任何具体类型都可能与 ? 不匹配
 
    // ✅ null 是唯一的例外，因为 null 可以赋值给任何引用类型
    list.add(null);
}
 
public static void main(String[] args) {
    List<String> strings = Arrays.asList("A", "B", "C");
    List<Integer> numbers = Arrays.asList(1, 2, 3);
    List<Dog> dogs = Arrays.asList(new Dog("Buddy"));
 
    // ✅ 全部合法！List<?> 可以接受任何类型实参的 List
    printListInfo(strings);
    printListInfo(numbers);
    printListInfo(dogs);
}

// List<Object> vs List<?>
 
// List<Object>：明确指定元素类型为 Object
// 可以添加任何对象（因为所有类都是 Object 的子类）
List<Object> objectList = new ArrayList<>();
objectList.add("hello");   // ✅ String 是 Object 子类
objectList.add(123);       // ✅ Integer 是 Object 子类
 
// 但 List<Object> 不能接受 List<String>！因为泛型不变
// List<Object> ref = new ArrayList<String>();  // ❌ 编译错误
 
// List<?>：未知类型
// 不能添加元素（除了 null），但可以接受任何 List
List<?> wildcardList;
wildcardList = new ArrayList<String>();   // ✅
wildcardList = new ArrayList<Integer>();  // ✅
wildcardList = new ArrayList<Object>();   // ✅
// wildcardList.add("test");  // ❌ 编译错误

// Raw type vs 无界通配符 —— 编译器行为对比
List rawList = new ArrayList<String>();
rawList.add(123);  // ⚠️ 编译器只给 warning，不报错，运行时可能 ClassCastException
 
List<?> safeList = new ArrayList<String>();
// safeList.add(123);  // ❌ 编译器直接报错，把问题拦截在编译期

// 计算任意 Number 子类型列表的总和
// 使用上界通配符，使方法能接受 List<Integer>、List<Double> 等
public static double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number num : list) {
        // 取出的每个元素都可以安全地当作 Number 使用
        // 因为 ? extends Number 保证了元素至少是 Number
        sum += num.doubleValue();
    }
    return sum;
}
 
public static void main(String[] args) {
    List<Integer> intList = Arrays.asList(1, 2, 3);
    List<Double> doubleList = Arrays.asList(1.1, 2.2, 3.3);
    List<Long> longList = Arrays.asList(100L, 200L, 300L);
 
    // ✅ 全部合法！Integer、Double、Long 都 extends Number
    System.out.println(sumOfList(intList));     // 6.0
    System.out.println(sumOfList(doubleList));  // 6.6
    System.out.println(sumOfList(longList));    // 600.0
 
    // 如果方法签名是 List<Number>，上面三个调用全部编译失败！
}

public static void cannotWrite(List<? extends Number> list) {
    // ✅ 读取完全没问题
    Number first = list.get(0);  // 编译器知道元素至少是 Number
 
    // ❌ 以下写入操作全部编译失败
    // list.add(1);        // 万一实际是 List<Double> 呢？
    // list.add(1.0);      // 万一实际是 List<Integer> 呢？
    // list.add(new Number() { ... }); // 同理
 
    // ✅ null 仍然是唯一的例外
    list.add(null);
}

// 一个通用的 ViewHolder 绑定工具方法
// 接受任何 Animal 子类的列表，只读取不修改
public static void bindAnimalViews(
        List<? extends Animal> animals,  // 可以传入 List<Dog>、List<Cat> 等
        AnimalAdapter adapter) {
 
    for (int i = 0; i < animals.size(); i++) {
        // 取出的元素类型是 Animal，可以安全调用 Animal 的方法
        Animal animal = animals.get(i);
        adapter.bindData(i, animal.getName(), animal.getSound());
    }
}

// 接口作为上界
public static void processComparables(List<? extends Comparable<String>> list) {
    for (Comparable<String> item : list) {
        // 可以安全调用 Comparable 接口的方法
        int result = item.compareTo("baseline");
        System.out.println("Compare result: " + result);
    }
}

// 下界通配符的读写行为演示
public static void demonstrateSuperWildcard(List<? super Dog> list) {
    // ✅ 写入 Dog 及其子类 —— 完全安全
    list.add(new Dog("Buddy"));              // Dog 本身，OK
    list.add(new GoldenRetriever("Max"));    // Dog 的子类，OK
 
    // ❌ 不能写入 Dog 的父类
    // list.add(new Animal("Generic"));  // 编译错误！万一实际是 List<Dog> 呢？
 
    // ⚠️ 读取只能当 Object 处理
    Object item = list.get(0);  // 只能用 Object 接收
    // Dog dog = list.get(0);   // ❌ 编译错误！不能保证取出的一定是 Dog
 
    // 如果确实需要当 Dog 用，必须手动强转（不推荐）
    if (item instanceof Dog) {
        Dog dog = (Dog) item;
        System.out.println(dog.getName());
    }
}
 
public static void main(String[] args) {
    List<Dog> dogList = new ArrayList<>();
    List<Animal> animalList = new ArrayList<>();
    List<Object> objectList = new ArrayList<>();
 
    // ✅ 全部合法！Dog、Animal、Object 都是 Dog 的"super"
    demonstrateSuperWildcard(dogList);
    demonstrateSuperWildcard(animalList);
    demonstrateSuperWildcard(objectList);
 
    // ❌ 不合法！GoldenRetriever 是 Dog 的子类，不是 super
    // List<GoldenRetriever> grList = new ArrayList<>();
    // demonstrateSuperWildcard(grList);  // 编译错误
}

// java.util.Collections 中的 copy 方法签名
// dest 是消费者（接收数据），用 ? super T
// src 是生产者（提供数据），用 ? extends T
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    // 从 src 中读取（extends 保证可以安全读取为 T）
    // 往 dest 中写入（super 保证可以安全写入 T）
    for (int i = 0; i < src.size(); i++) {
        T item = src.get(i);    // ✅ 从 Producer 读取
        dest.set(i, item);      // ✅ 向 Consumer 写入
    }
}
 
// 使用示例
public static void main(String[] args) {
    List<Dog> dogs = Arrays.asList(new Dog("A"), new Dog("B"));
    List<Animal> animals = new ArrayList<>(Arrays.asList(null, null));
 
    // Dog 列表作为源（Producer），Animal 列表作为目标（Consumer）
    // T 被推断为 Dog
    // src: List<? extends Dog> ← List<Dog> ✅
    // dest: List<? super Dog> ← List<Animal> ✅（Animal 是 Dog 的 super）
    Collections.copy(animals, dogs);
}

┌──────────────────┬──────────────┬──────────────┬──────────────┐
│      特性         │    List<?>   │ List<? ext T>│ List<? sup T>│
├──────────────────┼──────────────┼──────────────┼──────────────┤
│ 含义             │ 任意类型      │ T 或 T 的子类 │ T 或 T 的父类 │
│ 读取元素类型      │ Object       │ T            │ Object       │
│ 写入能力         │ ❌ (仅 null) │ ❌ (仅 null)  │ ✅ T 及子类   │
│ 典型用途         │ 只读 + 类型   │ 生产者        │ 消费者        │
│                  │ 无关操作      │ (Producer)   │ (Consumer)   │
│ 协变/逆变        │ —            │ 协变          │ 逆变          │
│ PECS 角色        │ —            │ PE           │ CS           │
└──────────────────┴──────────────┴──────────────┴──────────────┘

List<? extends Number> list1 = new ArrayList<Integer>();
List<? super Integer> list2 = new ArrayList<Number>();
 
list1.add(1);                    // Line A
Number n = list1.get(0);         // Line B
list2.add(1);                    // Line C
Integer i = list2.get(0);       // Line D

// 一个简单的工具方法：把 src 中的所有元素拷贝到 dest 中
// 这是一个"看起来合理但实际上非常不灵活"的签名
public static <T> void copy(List<T> dest, List<T> src) {
    for (T item : src) {
        dest.add(item);
    }
}

List<Number> numbers = new ArrayList<>();
List<Integer> integers = Arrays.asList(1, 2, 3);
 
// 编译错误！List<Integer> 不是 List<Number>
copy(numbers, integers);

// src 是生产者：我们只从 src 中"读取"元素
// 使用 ? extends T，表示 src 中的元素至少是 T 或 T 的子类
public static <T> void copyFrom(List<T> dest, List<? extends T> src) {
    for (T item : src) {   // 读取操作 —— 安全，取出来的一定是 T 或其子类
        dest.add(item);     // 写入 dest —— dest 的类型是精确的 List<T>，安全
    }
}

List<? extends Number> producer = new ArrayList<Integer>();
 
// ✅ 读取：编译器知道里面的元素"至少是 Number"，所以可以安全赋值给 Number 引用
Number n = producer.get(0);
 
// ❌ 写入：编译器不知道这个 List 的实际类型参数到底是 Integer、Double 还是 Float
// 如果实际是 List<Integer>，你塞一个 Double 进去就破坏了类型安全
producer.add(3.14);  // 编译错误
producer.add(42);    // 编译错误，即使是 Integer 也不行

// dest 是消费者：我们只往 dest 中"写入"元素
// 使用 ? super T，表示 dest 能接受 T 及 T 的子类对象
public static <T> void copyInto(List<? super T> dest, List<T> src) {
    for (T item : src) {    // 从精确类型的 src 中读取
        dest.add(item);      // 写入操作 —— 安全，dest 的实际类型是 T 或 T 的父类
    }
}

List<? super Integer> consumer = new ArrayList<Number>();
 
// ✅ 写入：编译器知道实际类型至少是 Integer 的父类（Number、Object 等）
// 根据多态，Integer 对象一定可以赋值给 Number 或 Object 类型的引用
consumer.add(42);           // 安全
consumer.add(Integer.valueOf(100)); // 安全
 
// ❌ 精确读取：编译器不知道实际类型是 Number 还是 Object
// 所以取出来只能当 Object 用，失去了类型信息
// Number n = consumer.get(0);  // 编译错误
Object obj = consumer.get(0);    // 只能用 Object 接收

public class PECSDemo {
 
    // 终极版本：src 是 Producer（extends），dest 是 Consumer（super）
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (T item : src) {    // 从 Producer 中读取，类型安全
            dest.add(item);      // 向 Consumer 中写入，类型安全
        }
    }
 
    public static void main(String[] args) {
        // 场景1：Integer 列表拷贝到 Number 列表
        List<Number> numbers = new ArrayList<>();
        List<Integer> integers = Arrays.asList(1, 2, 3);
        copy(numbers, integers);  // ✅ T 推断为 Integer
 
        // 场景2：Integer 列表拷贝到 Object 列表
        List<Object> objects = new ArrayList<>();
        copy(objects, integers);  // ✅ T 推断为 Integer
 
        // 场景3：Double 列表也能拷贝到 Number 列表
        List<Double> doubles = Arrays.asList(1.1, 2.2);
        copy(numbers, doubles);   // ✅ T 推断为 Double
 
        System.out.println(numbers); // [1, 2, 3, 1.1, 2.2]
    }
}

// JDK 源码中的签名，完美遵循 PECS
public static <T> void copy(List<? super T> dest, List<? extends T> src)

// ========== 1. Collections.addAll ==========
// target 是 Consumer（接收元素），所以用 ? super T
public static <T> boolean addAll(Collection<? super T> c, T... elements)
 
// 使用示例：
List<Number> nums = new ArrayList<>();
Collections.addAll(nums, 1, 2, 3);  // ✅ Integer 是 Number 的子类
 
 
// ========== 2. Collections.max ==========
// coll 是 Producer（提供元素供比较），所以用 ? extends T
public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll)
// 注意这里的 Comparable<? super T>：比较器消费 T 的父类型，也是 PECS 的体现
 
 
// ========== 3. Stream.collect ==========
// Collector 的签名中也大量使用了 PECS
<R, A> R collect(Collector<? super T, A, R> collector)
// Collector 消费流中的元素（Consumer），所以是 ? super T
 
 
// ========== 4. Optional.orElseGet ==========
// Supplier 是 Producer（生产一个值），所以概念上对应 extends 思想
public T orElseGet(Supplier<? extends T> supplier)

import java.util.*;
import java.util.function.Predicate;
 
public class PECSAdvanced {
 
    /**
     * 从 src（Producer）中读取元素，用 predicate 过滤，写入 dest（Consumer）
     *
     * @param dest      目标集合，消费者角色，使用 ? super T
     * @param src       源集合，生产者角色，使用 ? extends T
     * @param predicate 过滤条件，消费 T 类型元素进行判断，使用 ? super T
     * @param <T>       元素类型
     */
    public static <T> void filterAndCollect(
            Collection<? super T> dest,        // Consumer: 往里写
            Collection<? extends T> src,        // Producer: 从中读
            Predicate<? super T> predicate) {   // Consumer: 消费元素做判断
 
        for (T item : src) {                   // 从 Producer 读取，安全
            if (predicate.test(item)) {        // Predicate 消费元素
                dest.add(item);                // 向 Consumer 写入，安全
            }
        }
    }
 
    public static void main(String[] args) {
        // 源数据：Integer 列表
        List<Integer> source = Arrays.asList(1, -2, 3, -4, 5, -6);
 
        // 目标：收集到 Number 列表中（Integer 的父类）
        List<Number> positiveNumbers = new ArrayList<>();
 
        // 过滤条件：用 Number 级别的 Predicate（判断是否大于 0）
        // 这个 Predicate<Number> 可以处理任何 Number 子类
        Predicate<Number> isPositive = n -> n.doubleValue() > 0;
 
        // 完美运行：
        // src: List<Integer>       匹配 Collection<? extends Integer>  ✅ Producer
        // dest: List<Number>       匹配 Collection<? super Integer>    ✅ Consumer
        // predicate: Predicate<Number> 匹配 Predicate<? super Integer> ✅ Consumer
        filterAndCollect(positiveNumbers, source, isPositive);
 
        System.out.println(positiveNumbers); // [1, 3, 5]
    }
}

// === 你写的源代码 ===
public class Box<T> {
    private T value;           // T 是类型参数
 
    public void set(T value) { // 方法参数使用 T
        this.value = value;
    }
 
    public T get() {           // 返回类型使用 T
        return value;
    }
}

// === 编译器擦除后的等价代码（字节码层面）===
public class Box {
    private Object value;           // T 被替换为 Object
 
    public void set(Object value) { // T 被替换为 Object
        this.value = value;
    }
 
    public Object get() {           // T 被替换为 Object
        return value;
    }
}

// === 你写的源代码 ===
Box<String> box = new Box<>();  // 声明 Box<String>
box.set("Hello");               // 传入 String
String val = box.get();         // 直接拿到 String，无需手动转型
 
// === 编译器擦除后的等价代码 ===
Box box = new Box();            // 泛型参数消失了
box.set("Hello");               // 传入的还是 String（String 本身就是 Object 子类）
String val = (String) box.get();// 编译器自动插入了强制转换！

// === 源代码：T 有上界 Comparable ===
public class SortedBox<T extends Comparable<T>> {
    private T value;
 
    public int compareTo(T other) {
        return value.compareTo(other); // 编译期知道 T 有 compareTo 方法
    }
}

// === 擦除后：T 被替换为上界 Comparable ===
public class SortedBox {
    private Comparable value;          // T → Comparable（不是 Object）
 
    public int compareTo(Comparable other) {
        return value.compareTo(other); // 调用 Comparable.compareTo
    }
}

// T 同时约束了 Serializable 和 Comparable
// 擦除后 T → Serializable（第一个约束）
public class MultiBox<T extends Serializable & Comparable<T>> {
    private T value; // 擦除后变成 private Serializable value;
}

public class ErasureProof {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();   // List<String>
        List<Integer> integers = new ArrayList<>();  // List<Integer>
 
        // 获取运行时的 Class 对象
        Class<?> c1 = strings.getClass();   // java.util.ArrayList
        Class<?> c2 = integers.getClass();  // java.util.ArrayList
 
        // 比较两个 Class 对象 —— 结果为 true！
        System.out.println(c1 == c2);       // true：运行时它们是同一个类
 
        // instanceof 也无法区分泛型类型
        // if (strings instanceof List<String>) {} // 编译错误！
        if (strings instanceof List<?>) {}          // 只能用无界通配符
        if (strings instanceof List) {}             // 或者用原始类型
    }
}

public class ErasureHack {
    public static void main(String[] args) throws Exception {
        List<String> list = new ArrayList<>(); // 声明为 List<String>
        list.add("Hello");                     // 正常添加 String
 
        // 通过反射获取 add 方法 —— 运行时签名是 add(Object)
        // 因为泛型已被擦除，参数类型是 Object 而非 String
        list.getClass()
            .getMethod("add", Object.class)
            .invoke(list, 123);                // 强行塞入一个 Integer！
 
        System.out.println(list);              // [Hello, 123] —— 居然成功了
        // String s = list.get(1);             // 运行时抛出 ClassCastException
    }
}

// 泛型接口
public interface Transformer<T> {
    T transform(T input); // 擦除后签名：Object transform(Object)
}
 
// 实现类，指定 T = String
public class StringTransformer implements Transformer<String> {
    @Override
    public String transform(String input) { // 签名：String transform(String)
        return input.toUpperCase();
    }
}

// === 编译器为 StringTransformer 生成的实际字节码（反编译后）===
public class StringTransformer implements Transformer {
 
    // 你写的方法（真正的业务逻辑）
    public String transform(String input) {
        return input.toUpperCase();
    }
 
    // 编译器自动生成的桥接方法（bridge method）
    // 这个方法才是真正"覆盖"了接口中 Object transform(Object) 的方法
    public /* synthetic bridge */ Object transform(Object input) {
        return this.transform((String) input); // 强转后委托给真正的方法
    }
}

import java.lang.reflect.Method;
 
public class BridgeMethodProof {
    public static void main(String[] args) {
        // 遍历 StringTransformer 的所有方法
        for (Method m : StringTransformer.class.getDeclaredMethods()) {
            System.out.printf(
                "方法名: %-12s 参数类型: %-10s 返回类型: %-10s 是否桥接: %s%n",
                m.getName(),
                m.getParameterTypes()[0].getSimpleName(),
                m.getReturnType().getSimpleName(),
                m.isBridge()   // 关键方法：判断是否为桥接方法
            );
        }
    }
}

方法名: transform    参数类型: String     返回类型: String     是否桥接: false
方法名: transform    参数类型: Object     返回类型: Object     是否桥接: true

public class Parent {
    public Object create() {       // 返回 Object
        return new Object();
    }
}
 
public class Child extends Parent {
    @Override
    public String create() {       // 返回 String（Object 的子类）—— 协变返回
        return "child";
    }
}

// Child 类的实际字节码
public class Child extends Parent {
    public String create() {                    // 你写的方法
        return "child";
    }
 
    public /* synthetic bridge */ Object create() { // 桥接方法
        return this.create();                       // 委托给 String create()
    }
}

public class ErasurePitfalls {
 
    // ❌ 坑1：无法基于泛型参数进行方法重载
    // 擦除后两个方法签名都是 process(List)，冲突！
    // public void process(List<String> list) {}
    // public void process(List<Integer> list) {} // 编译错误
 
    // ❌ 坑2：无法对类型参数使用 instanceof
    public <T> void check(Object obj) {
        // if (obj instanceof T) {}  // 编译错误：T 在运行时不存在
        // T t = new T();            // 编译错误：无法实例化类型参数
    }
 
    // ❌ 坑3：静态字段不能使用类的类型参数
    // （因为静态字段属于类本身，而泛型类型属于实例）
    // static T sharedValue;         // 编译错误
 
    // ✅ 正确做法：通过 Class<T> 传递运行时类型信息
    public <T> T createInstance(Class<T> clazz) throws Exception {
        return clazz.getDeclaredConstructor().newInstance(); // 利用反射创建实例
    }
}

import java.lang.reflect.*;
import java.util.List;
 
public class GenericSignatureRetention {
 
    // 字段声明中的泛型信息会被保留在类元数据中
    private List<String> names;
 
    public static void main(String[] args) throws Exception {
        // 获取字段 "names" 的声明类型
        Field field = GenericSignatureRetention.class
                .getDeclaredField("names");
 
        // getGenericType() 返回带泛型信息的 Type
        Type genericType = field.getGenericType();
 
        if (genericType instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericType;
            System.out.println("原始类型: " + pt.getRawType());
            // 输出: 原始类型: interface java.util.List
 
            Type[] typeArgs = pt.getActualTypeArguments();
            System.out.println("类型参数: " + typeArgs[0]);
            // 输出: 类型参数: class java.lang.String
        }
    }
}

// Gson 的 TypeToken 利用了"子类保留父类泛型签名"的特性
// 匿名子类 {} 的父类是 TypeToken<List<String>>
// 这个泛型信息会被保留在字节码的 Signature 属性中
Type type = new TypeToken<List<String>>(){}.getType();
// type = java.util.List<java.lang.String>  ← 运行时拿到了完整泛型信息

// Java：无法在运行时获取 T 的具体类型
public <T> void printType() {
    // System.out.println(T.class); // 编译错误！
}

// Kotlin：reified + inline 让 T 在运行时可用
inline fun <reified T> printType() {
    println(T::class.java) // 合法！因为 inline 会在调用处展开代码
}

public class Quiz {
    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        List<Integer> b = new ArrayList<>();
        System.out.println(a.getClass() == b.getClass());
        System.out.println(a.getClass().getName());
    }
}

// 数组协变演示
Integer[] intArr = {1, 2, 3};          // 创建一个 Integer 数组
Number[] numArr = intArr;               // 合法！Integer[] 是 Number[] 的子类型（协变）
 
numArr[0] = 3.14;                       // 编译通过！编译器只看到 Number[]，Double 是 Number 子类
                                        // 但运行时 JVM 知道底层是 Integer[]
                                        // 抛出 ArrayStoreException ❌

// ⚠️ 假设 Java 允许创建泛型数组（实际不允许！）
List<String>[] stringLists = new List<String>[10];  // 假设这行合法
 
// 步骤 1：利用数组协变，将 List<String>[] 赋给 Object[]
Object[] objArr = stringLists;                       // 数组协变，合法
 
// 步骤 2：往 Object[] 中塞入一个 List<Integer>
objArr[0] = List.of(42);                             // 运行时能检查吗？
// 运行时数组的实际类型是 List[]（擦除后）
// List.of(42) 的运行时类型也是 List
// List 存入 List[] —— JVM 认为完全合法 ✅（没有 ArrayStoreException！）
 
// 步骤 3：通过原始引用取出，编译器认为是 List<String>
String s = stringLists[0].get(0);                    // 编译器插入 (String) 强转
// 实际取出的是 Integer 42
// ClassCastException ❌ 类型安全被彻底击穿！