// JDK 1.4 写法：原始类型（raw type），编译器只知道里面装的是 Object
List names = new ArrayList();
names.add("张三");
names.add("李四");

// 取出来必须强转，编译器不做任何检查
String first = (String) names.get(0);
System.out.println(first.length());

List data = new ArrayList();
data.add("订单号-A1001");

// 某个不熟这块代码的人往同一个容器里塞了日期
data.add(new java.util.Date());

// 编译期完全静默，运行期直接 ClassCastException
for (int i = 0; i < data.size(); i++) {
    String s = (String) data.get(i);   // 第 2 个元素炸
    System.out.println(s.toUpperCase());
}

// 泛型写法
List<String> names = new ArrayList<>();
names.add("张三");
// names.add(new Date());      // 编译错误：不兼容的类型
String first = names.get(0);   // 无需强转，编译器保证它一定是 String

/**
 * 一个简单的泛型容器：T 是类型参数，在类体内可以当类型用
 */
public class Box<T> {
    private T value;

    public T get() { return value; }
    public void set(T value) { this.value = value; }

    // 类型参数也可以出现在参数、返回值、局部变量、异常声明中
    public boolean isEqualTo(T other) {
        return other != null && other.equals(this.value);
    }
}

// 使用
Box<String> strBox = new Box<>();     // JDK 7+ 菱形运算符
strBox.set("hello");
String v = strBox.get();

public class GenericMethods {

    // <T> 出现在 static 与返回值之间 —— 这就是泛型方法的标志
    public static <T> T pick(T a, T b) {
        return Math.random() > 0.5 ? a : b;
    }

    // 多个类型参数，且可以有边界
    public static <K, V> boolean sameKey(Map<K, V> m1, Map<K, V> m2) {
        return m1.keySet().equals(m2.keySet());
    }

    // 边界：T 必须是 Number 的子类
    public static <T extends Number> double sum(List<T> numbers) {
        double total = 0.0;
        for (T n : numbers) { total += n.doubleValue(); }
        return total;
    }

    public static void main(String[] args) {
        // 不需要写 GenericMethods.<String>pick(...)，编译器会推断
        String s = pick("a", "b");                    // T 推断为 String
        Integer i = pick(1, 2);                       // T 推断为 Integer
        double d = sum(List.of(1, 2.5, 3L));          // T 推断为 Number & Comparable<...> 的交集
    }
}

// 定义：接口名后带类型参数
public interface Repository<T, ID> {
    T findById(ID id);
    ID save(T entity);
    void deleteById(ID id);
}

// 实现一：实现时直接指定具体类型，之后实现类不再是泛型类
public class UserRepository implements Repository<User, Long> {
    @Override public User findById(Long id) { /* ... */ return null; }
    @Override public Long save(User entity) { /* ... */ return 1L; }
    @Override public void deleteById(Long id) { /* ... */ }
}

// 实现二：实现类继续保留类型参数，把决定权交给使用者
public abstract class AbstractRepository<T, ID> implements Repository<T, ID> {
    protected abstract Class<T> getEntityClass();   // 见 3.4 的 Class<T> token 模式
}

public class VarargsDemo {

    // 错误：静态方法不能用类的类型参数 T
    // public static T bad(T a) { return a; }        // 编译错误

    // 正确：静态方法自己声明类型参数
    public static <E> List<E> listOf(E... elements) {
        List<E> result = new ArrayList<>();
        for (E e : elements) { result.add(e); }
        return result;
    }

    // 泛型可变参数会产生"堆污染"警告，JDK 7 起可用 @SafeVarargs 抑制
    @SafeVarargs
    public static <E> void printAll(E... elements) {
        for (E e : elements) { System.out.println(e); }
    }
}

// JDK 7 之前
Map<String, List<Integer>> map1 = new HashMap<String, List<Integer>>();
// JDK 7+
Map<String, List<Integer>> map2 = new HashMap<>();

static void process(List<String> names) { /* ... */ }

// JDK 7：编译错误！JDK 7 只能从"赋值语句"推断，不会用形参类型去推断实参
// process(Collections.emptyList());

// JDK 8：OK，目标类型为 List<String>，emptyList 的 T 被推断为 String
process(Collections.emptyList());

// JDK 8 起，嵌套泛型方法调用也能推断
List<String> names = List.of("a", "b");
Stream<String> stream = names.stream().map(String::toUpperCase);

// 推断不出来：实参都是 null，缺少推断依据
List<String> empty1 = Collections.<String>emptyList();

// 推断结果不是我想要的：想构造 List<Object>，但根据实参推断成了 List<String>
List<Object> objs = Collections.<Object>unmodifiableList(new ArrayList<String>());

// 链式调用中锁定类型
Optional<String> opt = Optional.<String>ofNullable(null);

// 类型见证也常用于流管道的收口
Stream<String> s = Stream.<String>of("a", "b", "c").map(x -> x);

class Erasure<T> {                       // 无界：T -> Object
    private T value;
    public T get() { return value; }
}

class Bounded<T extends Number> {        // 有界：T -> Number
    private T value;
    public double toDouble() { return value.doubleValue(); }  // 调用擦除为 Number.doubleValue()
}

class Multi<T extends Comparable<T> & java.io.Serializable> {  // 多边界：T -> Comparable
    private T value;
    public int cmp(T o) { return value.compareTo(o); }         // 调用 Comparable.compareTo(Object)
}

public class Limits<T> {

    // 限制一：不能 new T() —— 擦除后变成 new Object()，不是你要的
    // T create() { return new T(); }                 // 编译错误

    // 限制二：不能 new T[] —— 数组需要在运行期知道元素类型
    // T[] createArray(int n) { return new T[n]; }    // 编译错误：generic array creation

    // 限制三：不能 instanceof T / 不能对精确泛型类型做 instanceof
    boolean isString(Object o) {
        // return o instanceof T;                     // 编译错误
        // return o instanceof List<String>;          // 编译错误：illegal generic type for instanceof
        return o instanceof List<?> ;                 // 只有无界通配符合法
    }

    // 限制四：静态成员不能使用类的类型参数
    // private static T cached;                       // 编译错误
    // public static T identity(T t) { return t; }    // 编译错误（应为静态泛型方法，见 2.5）

    // 限制五：不能仅靠类型参数不同来重载
    void overload(List<String> a) { }
    // void overload(List<Integer> a) { }             // 编译错误：have the same erasure
}

import java.lang.reflect.Array;
import java.util.function.Supplier;

public class Workarounds<T> {
    private final Class<T> typeToken;      // Class<T> token 模式
    private final Supplier<T> factory;     // 工厂模式

    // 构造时把"类型信息"和"构造行为"一起注入，弥补擦除
    public Workarounds(Class<T> typeToken, Supplier<T> factory) {
        this.typeToken = typeToken;
        this.factory = factory;
    }

    // 绕过限制一：用 Supplier 代替 new T()
    public T create() {
        return factory.get();
    }

    // 绕过限制二：反射创建真实类型的数组（元素是 null，不需要强转元素本身）
    @SuppressWarnings("unchecked")
    public T[] createArray(int length) {
        return (T[]) Array.newInstance(typeToken, length);
    }

    // 绕过限制三：用 Class.isInstance 代替 instanceof
    public boolean isOfType(Object o) {
        return typeToken.isInstance(o);
    }

    public static void main(String[] args) {
        var w = new Workarounds<>(String.class, String::new);
        String s = w.create();             // ""
        String[] arr = w.createArray(3);   // 真正的 String[]，不是 Object[]
        System.out.println(arr.getClass());        // class [Ljava.lang.String;
        System.out.println(w.isOfType("abc"));     // true
        System.out.println(w.isOfType(123));       // false
    }
}

// 源文件 Box.java
public class Box<T> {
    private T value;
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

// ===== javap -v -p Box.class（节选，省略常量池与无关行）=====
// 类级别的 Signature：泛型声明被保存在这里，descriptor 里没有
//   Signature: #13   // <T:Ljava/lang/Object;>Ljava/lang/Object;

{
  private T value;
    descriptor: Ljava/lang/Object;            // <-- 字段描述符：T 已被擦成 Object
    flags: (0x0002) ACC_PRIVATE
    Signature: #8                             // TT;      <-- 泛型信息仅存于 Signature

  public T get();
    descriptor: ()Ljava/lang/Object;          // <-- 返回值擦成 Object
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: getfield      #7                  // Field value:Ljava/lang/Object;
         4: areturn
    Signature: #12                            // ()TT;    <-- 真实的泛型签名

  public void set(T);
    descriptor: (Ljava/lang/Object;)V         // <-- 参数擦成 Object
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: putfield      #7                  // Field value:Ljava/lang/Object;
         5: return
    Signature: #17                            // (TT;)V
}

// 源文件 UseBox.java
public class UseBox {
    public static void main(String[] args) {
        Box<String> box = new Box<>();
        box.set("hello");
        String s = box.get();     // 这一行，编译器替我们插了 checkcast
    }
}

// ===== javap -c UseBox.class（main 方法）=====
public static void main(java.lang.String[]);
  Code:
     0: new           #2                  // class Box
     3: dup
     4: invokespecial #3                  // Method Box."<init>":()V
     7: astore_1
     8: aload_1
     9: ldc           #4                  // String hello
    11: invokevirtual #5                  // Method Box.set:(Ljava/lang/Object;)V   <-- 按擦除签名调用
    14: aload_1
    15: invokevirtual #6                  // Method Box.get:()Ljava/lang/Object;
    18: checkcast     #7                  // class java/lang/String                  <-- 自动插入！
    21: astore_2
    22: return

import java.util.ArrayList;

// 源码：重写了 ArrayList<String> 的 add(String)
class MyList extends ArrayList<String> {
    @Override
    public boolean add(String s) {
        System.out.println("adding: " + s);
        return super.add(s);
    }
}

List rawOrObjectList = new MyList();
rawOrObjectList.add(new Object());   // 按擦除签名，调用的是 add(Object)

// ===== javap -p -c MyList.class（节选）=====
class MyList extends java.util.ArrayList<java.lang.String> {
  // ① 程序员写的真实方法
  public boolean add(java.lang.String);
    descriptor: (Ljava/lang/String;)Z
    flags: (0x0001) ACC_PUBLIC
    Code:
       0: getstatic     #2   // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_1
       4: invokevirtual #3   // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       ...
      14: aload_0
      15: aload_1
      16: invokespecial #5   // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
      19: ireturn

  // ② 编译器生成的桥接方法：ACC_BRIDGE + ACC_SYNTHETIC
  public boolean add(java.lang.Object);
    descriptor: (Ljava/lang/Object;)Z
    flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #6   // class java/lang/String   <-- 先做类型检查
       5: invokevirtual #7   // Method add:(Ljava/lang/String;)Z   <-- 再转发给真实方法
       8: ireturn
}

class MyInt implements Comparable<MyInt> {
    private final int value;
    MyInt(int value) { this.value = value; }
    @Override public int compareTo(MyInt o) { return Integer.compare(value, o.value); }
}

// ===== javap -p -c MyInt.class（节选）=====
//   public int compareTo(MyInt);
//     descriptor: (LMyInt;)I
//
//   public int compareTo(java.lang.Object);
//     descriptor: (Ljava/lang/Object;)I
//     flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
//     Code:
//        0: aload_0
//        1: aload_1
//        2: checkcast     #5   // class MyInt
//        5: invokevirtual #6   // Method compareTo:(LMyInt;)I
//        8: ireturn

import java.util.List;
import java.util.ArrayList;

class Clash1 {
    // 两个方法擦除后都是 void m(List)，签名冲突
    public void m(List<String> list) { }
    // public void m(List<Integer> list) { }
    //   编译错误：name clash: m(List<Integer>) and m(List<String>) have the same erasure
}

class Clash2 extends ArrayList<String> {
    // ArrayList<String> 擦除后有 add(Object)，编译器还要为它生成桥接方法 add(Object)
    // 而这里手写的 add(Object) 擦除后同样是 add(Object)，且并不构成重写
    // public boolean add(Object o) { return true; }
    //   编译错误：name clash: add(Object) in Clash2 and add(E) in ArrayList have the same erasure,
    //            yet neither overrides the other
}

interface A { void f(List<String> x); }
interface B { void f(List<Integer> x); }
// class C implements A, B { }
//   编译错误：types A and B are incompatible; both define f(List), but with unrelated return types / erasure

List<String> strings = new ArrayList<>();
// List<Object> objects = strings;   // 编译错误：incompatible types

List<?> unknown = new ArrayList<String>();
// unknown.add("abc");          // 编译错误：add(capture of ?) 无法接受任何值（除 null）
unknown.add(null);             // 唯一例外：null 没有类型，可以加
Object o = unknown.get(0);     // 只能当 Object 用
int size = unknown.size();     // size() 不依赖元素类型，正常可用

List<? extends Number> nums = new ArrayList<Integer>();   // 任何 Number 的子类型的 List

Number n = nums.get(0);      // OK：读出来的东西"至少是个 Number"
// nums.add(1);              // 编译错误
// nums.add(2.0);            // 编译错误
// nums.add(null);           // 唯一例外

List<? super Integer> ints = new ArrayList<Number>();   // Integer 或其任一父类型的 List

ints.add(1);                 // OK：无论实际是 List<Integer>/List<Number>/List<Object>，
                             //     放一个 Integer 进去都合法
// ints.add(2.0);            // 编译错误：如果实际是 List<Integer>，Double 就非法
Object o = ints.get(0);      // 只能当 Object 用
// Integer i = ints.get(0);  // 编译错误：实际可能是 List<Number>，取出来未必是 Integer

public static void swapFirstTwo(List<?> list) {
    // list.set(0, list.set(1, list.get(0)));
    //   编译错误：The method set(int, capture#1-of ?) is not applicable
    //            for the arguments (int, capture#2-of ?)
}

public class Swap {
    // 公开 API 用通配符保持灵活
    public static void swap(List<?> list, int i, int j) {
        swapHelper(list, i, j);      // 捕获发生在这里：? 被绑定到某个具体的 E
    }

    // 私有 helper：类型参数 E 捕获了通配符代表的那个未知类型
    private static <E> void swapHelper(List<E> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));   // 合法：前后都是同一个 E
    }

    public static void main(String[] args) {
        List<String> l = new ArrayList<>(List.of("a", "b"));
        swap(l, 0, 1);
        System.out.println(l);       // [b, a]
    }
}

// 反面教材
// public static List<? extends Number> getNumbers() { ... }
// 调用方被迫写成：
// List<? extends Number> r = getNumbers();
// 之后既不能 add，也不能干净地声明变量

// 正面做法：返回值用精确类型参数或具体类型
public static <T extends Number> List<T> getNumbers(Class<T> type) {
    return new ArrayList<>();
}

List<Integer> ints2 = getNumbers(Integer.class);   // 干净

import java.util.*;

public class PecsDemo {
    static double sumOf(List<? extends Number> nums) {   // nums 是生产者 -> extends
        double total = 0;
        for (Number n : nums) { total += n.doubleValue(); }
        // nums.add(1);                    // 编译错误：required: capture of ? extends Number
        return total;
    }

    static void fillWithOnes(List<? super Integer> ints) {  // ints 是消费者 -> super
        for (int i = 0; i < 5; i++) {
            ints.add(1);                   // OK
        }
        // ints.add(2.5);                  // 编译错误：required: capture of ? super Integer
        // Integer x = ints.get(0);        // 编译错误：Object 无法转 Integer
        Object x = ints.get(0);            // 只能这样
    }

    static <T> void copyTo(List<? super T> dest, List<? extends T> src) {  // 一个消费一个生产
        for (int i = 0; i < src.size(); i++) {
            dest.set(i, src.get(i));       // src 产、dest 吃，方向完全对得上
        }
    }

    public static void main(String[] args) {
        System.out.println(sumOf(List.of(1, 2, 3)));            // Integer -> 6.0
        System.out.println(sumOf(List.of(1.5, 2.5)));           // Double  -> 4.0

        List<Number> sink = new ArrayList<>();
        fillWithOnes(sink);                                     // 可以喂 List<Number>
        List<Object> objSink = new ArrayList<>();
        fillWithOnes(objSink);                                  // 也可以喂 List<Object>
    }
}

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");

    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i = 0; i < srcSize; i++)
            dest.set(i, src.get(i));      // src 读（extends），dest 写（super）
    } else {
        ListIterator<? super T> di = dest.listIterator();   // 迭代器也遵循同样的边界
        ListIterator<? extends T> si = src.listIterator();
        for (int i = 0; i < srcSize; i++) {
            di.next();
            di.set(si.next());
        }
    }
}

// JDK 早期：过于严格，要求 T 必须直接实现 Comparable<T>
// public static <T extends Comparable<T>> T max(Collection<T> coll)

// JDK 现在的签名：两处放宽
//   1) Comparable<? super T>：允许 T 的比较逻辑继承自父类
//   2) Collection<? extends T>：允许传入 T 子类型的集合
public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll) {
    Iterator<? extends T> i = coll.iterator();
    T candidate = i.next();
    while (i.hasNext()) {
        T next = i.next();
        if (next.compareTo(candidate) > 0) candidate = next;
    }
    return candidate;
}

import java.lang.reflect.Array;
import java.util.*;

public class GenericArray {
    // 方案一（推荐）：用 List 代替数组
    static <T> List<T> asList(T... elements) {
        return new ArrayList<>(Arrays.asList(elements));
    }

    // 方案二：反射 Array.newInstance，得到真实运行期类型的数组
    @SuppressWarnings("unchecked")
    static <T> T[] newArray(Class<T> componentType, int length) {
        return (T[]) Array.newInstance(componentType, length);
    }

    // 方案三：先创建无界通配符数组再强转（最常用，但要清楚它是不安全的）
    @SuppressWarnings("unchecked")
    static List<String>[] newStringListArray(int length) {
        return (List<String>[]) new List<?>[length];   // 元素仍是 null，需逐个初始化
    }

    public static void main(String[] args) {
        String[] arr = newArray(String.class, 3);
        System.out.println(arr.getClass());            // class [Ljava.lang.String;

        List<String>[] lists = newStringListArray(2);
        lists[0] = new ArrayList<>(List.of("a"));
        lists[1] = new ArrayList<>(List.of("b"));
        System.out.println(Arrays.toString(lists));    // [[a], [b]]
    }
}

List<String>[] a = (List<String>[]) new List<?>[1];
Object[] objs = a;                 // 数组协变，编译通过
// objs[0] = new ArrayList<Integer>();   // 编译通过，运行期 ArrayStoreException

class Base<T> {
    void set(T t) { }
}
class Sub extends Base<String> {
    // 正确：这是重写，编译器会为它生成 set(Object) 桥接方法
    @Override void set(String s) { }

    // 错误：与桥接方法擦除冲突
    // void set(Object o) { }
    //   编译错误：name clash: set(Object) in Sub and set(T) in Base have the same erasure,
    //            yet neither overrides the other
}

// java.lang.Enum 的真实声明（JDK 17）
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    private final String name;
    private final int ordinal;
    protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
    public final int compareTo(E o) { ... }
    public final Class<E> getDeclaringClass() { ... }
}

// 使用时：Color 把自己作为类型参数传给 Enum
enum Color { RED, GREEN, BLUE }    // 编译器实际生成：final class Color extends Enum<Color>

abstract class Node<Self extends Node<Self>> {
    private Self next;
    @SuppressWarnings("unchecked")
    protected Self self() { return (Self) this; }

    @SuppressWarnings("unchecked")
    public Self next(Self n) { this.next = n; return self(); }
}
final class TextNode extends Node<TextNode> {
    private String text;
    public TextNode text(String t) { this.text = t; return this; }
}
// 用法：new TextNode().text("hi").next(otherTextNode)

public class GenericException {
    // 合法：类型参数可以作为 throws 子句的类型变量（要求 T extends Throwable）
    static <T extends Throwable> void throwAs(Class<T> type, String msg) throws T {
        try {
            T t = type.getConstructor(String.class).newInstance(msg);
            throw t;
        } catch (ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    static void demo() throws java.io.IOException {
        throwAs(java.io.IOException.class, "磁盘读失败");
    }

    // 非法：catch 子句不能使用类型参数
    // static <T extends Throwable> void badCatch() {
    //     try { } catch (T e) { }     // 编译错误：cannot use type parameter in catch clause
    // }

    // 非法：不能泛型化 Throwable 的子类
    // class MyException<T> extends Exception { }   // 编译错误
}

import java.lang.reflect.*;
import java.util.*;

// 模拟 Jackson / Fastjson2 的 TypeReference 思路
abstract class TypeReference<T> {
    private final Type type;
    protected TypeReference() {
        // 拿到 "TypeReference<List<User>>" 这个父类签名
        Type superclass = getClass().getGenericSuperclass();
        if (!(superclass instanceof ParameterizedType)) {
            throw new IllegalArgumentException("缺少泛型参数");
        }
        // 取出第一个实际类型参数，即 List<User>
        this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }
    public Type getType() { return type; }
}

class User { public String name; }

public class ReflectionDemo {
    // 字段上的泛型也能通过 Field.getGenericType() 拿到
    static class Holder {
        Map<String, List<User>> data;
    }

    public static void main(String[] args) throws Exception {
        // 匿名内部类会生成一个真实子类，其父类签名里带着 <List<User>>
        TypeReference<List<User>> ref = new TypeReference<List<User>>() {};
        System.out.println(ref.getType());
        // 输出：java.util.List<ReflectionDemo$User>

        ParameterizedType pt = (ParameterizedType) ref.getType();
        System.out.println(pt.getRawType());                 // interface java.util.List
        System.out.println(pt.getActualTypeArguments()[0]);  // class ReflectionDemo$User

        // 字段维度
        Field f = Holder.class.getDeclaredField("data");
        System.out.println(f.getGenericType());              // java.util.Map<java.lang.String, java.util.List<...$User>>
    }
}