Java 泛型核心机制与实战指南

使用 extends 关键字指定上界。这意味着泛型参数必须是该类型或其子类。

class MyArray<T extends Number> {
    public Object[] array = new Object[10];
    public void set(int pos, T val) { array[pos] = val; }
    public T get(int pos) { return (T) array[pos]; }
}

public class Test {
    public static void main(String[] args) {
        // 编译错误，因为 String 不是 Number 的子类型
        // MyArray<String> myArray1 = new MyArray<>();
        
        // 正常，因为 Integer 是 Number 的子类型
        MyArray<Integer> myArray = new MyArray<>();
    }
}

一个典型的例子是寻找数组中的最大值，这需要元素具备比较能力：

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

类型擦除机制

Java 的泛型在运行时是通过'类型擦除'实现的。这意味着编译器会在编译阶段移除泛型信息，将其替换为原始类型（Raw Type）或上界类型。JVM 在运行时并不保留泛型参数的具体信息。

例如，List<String> 和 List<Integer> 在编译后的字节码中都表现为 List。为了保持类型安全，编译器会执行以下操作：

1. 移除类型参数：字节码中不再包含泛型类型参数信息。
2. 替换为原始类型：泛型参数被替换为其上界（如 Comparable），若无上界则默认为 Object。
3. 插入类型转换：在读取元素时，编译器会自动插入从 Object 到目标类型的强制转换。
4. 生成桥接方法：为了兼容旧代码，编译器可能会生成桥接方法以处理泛型方法的覆盖问题。

这种设计保证了泛型代码能与非泛型代码无缝对接，但也带来了一些运行时限制，比如无法直接获取泛型的具体类型信息。

通配符的使用

当不确定具体类型时，可以使用通配符 ?。它代表了未知的类型，常用于方法参数中以提高灵活性。

class Message<T> {
    private T message;
    public T getMessage() { return message; }
    public void setMessage(T message) { this.message = message; }
}

public class Test {
    // 可以传入任意类型的 Message
    public static void fun(Message<?> temp) {
        System.out.println(temp.getMessage());
    }
    
    public static void main(String[] args) {
        Message<String> message = new Message<>();
        message.setMessage("你好！");
        fun(message);
        
        Message<Integer> message2 = new Message<>();
        message2.setMessage(199);
        fun(message2);
    }
}

通配符上界 (? extends T)

用于指定类型的上界，表示泛型参数必须是 T 或其子类。这主要用于读取数据（Producer Extends）。

• 特点：可以安全地读取元素，但无法写入（除了 null），因为编译器无法确定具体是哪个子类。

class Food { }
class Fruit extends Food { }
class Apple extends Fruit { }
class Banana extends Fruit { }

class Message<T> {
    private T message;
    public T getMessage() { return message; }
    public void setMessage(T message) { this.message = message; }
}

public class Test1 {
    public static void funExtends(Message<? extends Fruit> temp) {
        System.out.println(temp.getMessage());
        // 不能修改元素，因为不知道具体是 Apple 还是 Banana
        // temp.setMessage(new Banana());
        
        Fruit fruit = temp.getMessage(); // 向上转型接收
    }
}

通配符下界 (? super T)

用于指定类型的下界，表示泛型参数必须是 T 或其父类。这主要用于写入数据（Consumer Super）。

• 特点：可以添加 T 或其子类，但读取时只能得到 Object 类型。

class Plate<T> {
    private T plate;
    public T getPlate() { return plate; }
    public void setPlate(T plate) { this.plate = plate; }
}

public class Test1 {
    public static void funSuper(Plate<? super Fruit> temp) {
        // 可以添加 Fruit 或其子类
        temp.setPlate(new Apple());
        temp.setPlate(new Banana());
        
        // 读取时只能当作 Object
        System.out.println(temp.getPlate());
    }
}

泛型方法

泛型方法是指在整个方法签名中声明类型参数，使其独立于类的作用域。这在工具类中非常常见。

class Alg2 {
    // 泛型方法，静态方法也可以有泛型
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

public class Test2 {
    public static void main(String[] args) {
        Integer[] array = {1, 13, 51, 71, 19};
        Integer ret = Alg2.<Integer>findMax(array);
        System.out.println(ret);
    }
}

泛型的限制

在使用泛型时，有几个关键的限制需要注意，这些大多源于类型擦除机制：

1. 基本数据类型不可用：泛型只能使用引用类型。如需使用 int、double 等，必须使用对应的包装类（如 Integer、Double）。
2. 不能创建泛型数组：由于运行时类型信息丢失，new List<String>[10] 是不允许的。建议使用 ArrayList<List<String>> 替代。
3. 不能直接实例化泛型对象：new List<String>() 非法，应使用具体实现类如 new ArrayList<>()。
4. 运行时类型查询受限：instanceof 和 getClass() 无法检测泛型参数的具体类型，所有泛型在运行时都被视为原始类型。
5. 泛型类型无继承关系：即使 A 是 B 的子类，List<A> 也不是 List<B> 的子类。这是协变与逆变问题的根源。
6. 反射限制：反射无法直接获取泛型类型参数的具体信息，需结合注解或特定 API 处理。

掌握这些规则，能帮助我们在实际开发中避免常见的类型安全问题。