#泛型与类型擦除

// 编译前
public class Container<T> {
    private T value;

    public T getValue() { return value; }

    public void setValue(T value) { this.value = value; }
}

// 编译后：T 被替换为 Object
public class Container {
    private Object value; // T → Object

    public Object getValue() { return value; }

    // 桥接方法：为了保持多态
    @Override
    public String getValue() { return (String) this.value; } // ← 桥接方法

    public void setValue(Object value) { this.value = value; }
}

class NumericBox<T extends Number> { // 有上限
    private T value;
}

// 擦除后：
class NumericBox {
    private Number value; // T → Number（不是 Object）
}

List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123); // ❌ 编译错误

// 编译器在编译时插入了类型检查：
public boolean add(E e) {
    if (e instanceof String) { // ← 编译器插入的检查
        // ...
    }
    throw new ArrayStoreException();
}

class Parent<T> {
    T value;
    void set(T v) { this.value = v; }
}

class Child extends Parent<String> {
    // value 的类型在子类中已经是 String 了
    // 但父类的 set 方法签名是 set(T) → set(Object)

    @Override
    void set(String v) { this.value = v; } // 合法的重写
}

// 父类（擦除后）
class Parent {
    Object value;
    void set(Object v) { this.value = v; }
}

// 子类
class Child extends Parent<String> {
    String value; // 子类中 value 是 String，不是 Object

    // 编译器自动生成桥接方法：
    @Override
    void set(Object v) {
        this.set((String) v); // 委托给 set(String)
    }

    void set(String v) { this.value = v; }
}

// 多态调用：
Parent p = new Child();
p.set("hello"); // 调用桥接方法 set(Object) → set(String)
p.set(123);     // 编译错误（类型检查）

// ❌ 编译错误
List<int> list = new ArrayList<int>();

// ✅ 只能用包装类型
List<Integer> list = new ArrayList<>();

// ❌ 编译错误
T[] array = new T[10];

// ✅ 可以用反射创建
T[] array = (T[]) Array.newInstance(cls, 10);

// ✅ 可以声明，但初始化需要反射
class Container<T> {
    T[] array;
    Container(Class<T> cls, int size) {
        this.array = (T[]) Array.newInstance(cls, size);
    }
}

// ❌ 编译错误
T obj = new T();

// ✅ 可以用反射
T obj = cls.getDeclaredConstructor().newInstance();

// ❌ 编译错误
if (obj instanceof List<String>) { } // 编译失败

// ✅ 可以使用（不带泛型）
if (obj instanceof List) { } // 运行时会检查这个

// ❌ 编译错误：擦除后方法签名相同
class Container {
    void process(List<String> list) { }
    void process(List<Integer> list) { } // 擦除后都是 process(List)
}

// ❌ 编译错误
List<String>[] array = new ArrayList<String>[10];

// 为什么不行？
// List<String>[] 看起来可以放 List<String>
// 但擦除后变成 List[]，运行时可能放 List<Integer>
// 导致 ClassCastException

// ✅ 可以创建泛型数组的原始类型
List<String>[] array = new ArrayList[10]; // 警告但不报错
array[0] = new ArrayList<String>();
array[1] = new ArrayList<Integer>(); // 编译通过，但运行时不安全！

// 危险代码：
public class GenericContainer {
    private List<String> list = new ArrayList<>();

    public void add(Object item) {
        // 编译警告，但能通过
        list.add((String) item);
    }
}

// 触发：
GenericContainer container = new GenericContainer();
container.add(123); // 编译时只警告，运行时抛出 ClassCastException

// Jackson 的 TypeReference 用于保留泛型类型
// ❌ 错误：类型擦除后丢失泛型信息
User user = objectMapper.readValue(json, User.class); // 泛型信息丢失

// ✅ 正确：使用 TypeReference
User user = objectMapper.readValue(json, new TypeReference<User>() {});
// TypeReference 内部类保留了泛型类型

// ❌ 编译错误
List<Object> objects = new ArrayList<String>();

// List<String> 不是 List<Object> 的子类！
// 原因：如果是的话：
objects.add(123); // 合法（Object 可以是 Integer）
String s = objects.get(0); // ClassCastException！

// 这叫做"协变性问题"，Java 选择了类型安全

// 1. 集合类：List<T>, Map<K, V>, Set<T>
List<String> list = new ArrayList<>();

// 2. 通用工具类：Class<T>
public <T> T parse(String json, Class<T> clazz) {
    return objectMapper.readValue(json, clazz);
}

// 3. 通用算法：Comparable<T>
public class Sorter<T extends Comparable<T>> {
    public void sort(T[] array) {
        // T 实现了 Comparable 接口，保证有 compareTo 方法
    }
}

// 4. Lambda/Stream 的函数式接口
Function<String, Integer> parser = Integer::parseInt;