深入详解Java泛型擦除原理与限制

// 泛型类定义
public class Box<T extends Number> {
    private T value;
    public T getValue() { return value; }
    public void setValue(T value) { this.value = value; }
}
// 擦除后（编译为字节码的实际类型）
public class Box {  // 去掉泛型参数<T extends Number>
    private Number value;  // T被替换为上限Number
    public Number getValue() { return value; }  // 返回值类型变为Number
    public void setValue(Number value) { this.value = value; }  // 参数类型变为Number
}

// 泛型代码
List<String> list = new ArrayList<>();
list.add("hello");
String str = list.get(0);
// 擦除后（编译器生成的实际代码）
List list = new ArrayList();
list.add("hello");  // 编译时检查：确保添加的是String
String str = (String) list.get(0);  // 自动添加转型代码

// 错误：基本类型不能作为泛型参数
List<int> intList = new ArrayList<>();  // 编译报错
Map<double, boolean> map = new HashMap<>();  // 编译报错
// 正确：使用包装类
List<Integer> intList = new ArrayList<>();
Map<Double, Boolean> map = new HashMap<>();

public class Box<T> {
    public Box() {
        // 错误：不能实例化泛型类型T
        T value = new T();  // 编译报错
    }
}

public class Box<T> {
    private T value;
    // 传入Class对象，通过反射创建实例
    public Box(Class<T> clazz) throws InstantiationException, IllegalAccessException {
        value = clazz.newInstance();  // 合法
    }
}
// 使用
Box<String> box = new Box<>(String.class);  // 需显式传入Class对象

public class ArrayBox<T> {
    public void createArray() {
        // 错误：不能创建泛型数组
        T[] array = new T[10];  // 编译报错
    }
}

// 假设允许创建T[]，擦除后实际为Object[]
Object[] array = new Object[10];
String[] strArray = (String[]) array;  // 编译不报错（危险！）
strArray[0] = 123;  // 运行时抛ArrayStoreException（int不能存到String数组）

public class ArrayBox<T> {
    private Object[] array;
    public ArrayBox(int size) {
        array = new Object[size];  // 创建Object数组
    }
    public T get(int index) {
        return (T) array[index];  // 取出时转型
    }
    public void set(int index, T value) {
        array[index] = value;  // 存入时自动装箱
    }
}

List<String> list = new ArrayList<>();
// 错误：不能用instanceof判断泛型类型
if (list instanceof List<String>) {  // 编译报错
    // ...
}

public class GenericChecker<T> {
    private Class<T> clazz;
    public GenericChecker(Class<T> clazz) {
        this.clazz = clazz;
    }
    // 检查集合元素是否为T类型
    public boolean check(List<?> list) {
        for (Object obj : list) {
            if (!clazz.isInstance(obj)) {
                return false;
            }
        }
        return true;
    }
}
// 使用
GenericChecker<String> checker = new GenericChecker<>(String.class);
List<Object> list = Arrays.asList("a", "b", 123);
System.out.println(checker.check(list));  // false（包含Integer）

public class StaticBox<T> {
    // 正确：静态泛型方法有自己的类型参数S
    public static <S> S create(S obj) {
        return obj;
    }
}

// 泛型父类
class Parent<T> {
    public void setValue(T value) {}
}
// 子类指定泛型参数为String
class Child extends Parent<String> {
    @Override
    public void setValue(String value) {}  // 重写父类方法
}

Parent<String> parent = new Child();
parent.setValue("hello");  // 期望调用子类的setValue(String)

class Child extends Parent {
    // 编译器生成的桥接方法（重写父类的setValue(Object)）
    public void setValue(Object value) {
        setValue((String) value);  // 调用子类实际的setValue(String)
    }
    // 子类自己的方法
    public void setValue(String value) {}
}

import java.lang.reflect.Method;
public class BridgeDemo {
    public static void main(String[] args) {
        for (Method method : Child.class.getMethods()) {
            if (method.getName().equals("setValue")) {
                System.out.println("方法：" + method);
                System.out.println("是否桥接方法：" + method.isBridge());
            }
        }
    }
}
// 输出结果：
// 方法：public void Child.setValue(java.lang.String)
// 是否桥接方法：false
// 方法：public void Child.setValue(java.lang.Object)
// 是否桥接方法：true