Java 中的泛型（Generics）

Java 中的泛型（Generics）

1. 泛型的概念

泛型（Generics）是 Java 5 引入的一种特性，允许编写类型安全、可复用的代码。泛型主要用于类、接口和方法，能够在编译时进行类型检查，而不需要在运行时进行强制类型转换。

---

2. 泛型的优势

• 类型安全（Type Safety）：避免 ClassCastException，在编译阶段进行类型检查。
• 代码复用（Code Reusability）：相同的代码可以适用于多种数据类型，减少代码冗余。
• 可读性和可维护性：减少了不必要的类型转换。

---

3. Java 泛型的使用

(1) 泛型类

泛型类是在类定义时指定一个或多个类型参数，以支持不同类型的数据。

示例

// 定义一个泛型类
class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }
}

// 使用泛型类
public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setValue(10);
        System.out.println(intBox.getValue());  // 输出：10

        Box<String> strBox = new Box<>();
        strBox.setValue("Hello");
        System.out.println(strBox.getValue());  // 输出：Hello
    }
}

解释：

• T 是类型参数，实例化 Box<Integer> 时，T 变为 Integer，实例化 Box<String> 时，T 变为 String。
• setValue(T value) 只能接收 T 类型的数据，确保了类型安全。

---

(2) 泛型方法

泛型方法可以在方法级别使用泛型，而不需要整个类都是泛型的。

示例

class Util {
    // 泛型方法，`<T>` 指定泛型类型
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"A", "B", "C"};

        Util.printArray(intArray);  // 输出：1 2 3 4 5
        Util.printArray(strArray);  // 输出：A B C
    }
}

解释：

• public static <T> void printArray(T[] array)：<T> 说明该方法是泛型方法，可以接受不同类型的数组。

---

(3) 泛型接口

泛型接口允许接口的方法使用泛型，在实现时可以指定具体的类型。

示例

// 定义泛型接口
interface Generator<T> {
    T next();
}

// 实现泛型接口
class IntegerGenerator implements Generator<Integer> {
    private int value = 0;

    @Override
    public Integer next() {
        return value++;
    }
}

public class Main {
    public static void main(String[] args) {
        Generator<Integer> gen = new IntegerGenerator();
        System.out.println(gen.next());  // 输出：0
        System.out.println(gen.next());  // 输出：1
    }
}

解释：

• Generator<T> 是一个泛型接口，IntegerGenerator 具体实现时指定 T 为 Integer。
• next() 方法返回 Integer，符合泛型约束。

---

(4) 泛型的通配符

Java 提供 ? 作为泛型通配符，用于不确定具体类型的情况下，比如在方法参数中。

(a) ?（无界通配符）

public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

• List<?> 代表任意类型的 List，但是方法内部只能当作 Object 处理。

(b) ? extends T（上界通配符）

public static void printNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

• List<? extends Number> 允许 List<Integer>、List<Double> 等作为参数，但不能添加新元素。

© ? super T（下界通配符）

public static void addNumber(List<? super Integer> list) {
    list.add(10); // 允许添加 Integer 或其父类
}

• List<? super Integer> 允许 List<Integer>、List<Number> 或 List<Object> 作为参数。

---

(5) 泛型与类型擦除

Java 泛型是编译时特性，JVM 并不存储具体的泛型类型，所有泛型类型信息在编译后都会被类型擦除（Type Erasure）。

示例

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

System.out.println(list1.getClass() == list2.getClass());  // 输出：true

解释：

• 在运行时，List<String> 和 List<Integer> 的类型信息都会被擦除，实际的 List<T> 变成 List<Object>，所以 list1 和 list2 具有相同的 Class。

---

4. 泛型的限制

Java 泛型有一些限制：

1. 不能使用基本数据类型（必须使用包装类，如 List<int> 是非法的，应该用 List<Integer>）。
2. 不能创建泛型数组（T[] array = new T[10] 会报错）。
3. 不能在静态方法或静态变量中使用泛型类型参数（因为泛型类型参数是实例级的）。
4. 不能直接实例化泛型类型（T obj = new T(); 是非法的，应该使用 Class<T> 来实例化）。

---

5. 总结

特性	说明
泛型类	class Box<T> { T value; }
泛型方法	<T> void print(T item) {}
泛型接口	interface Generator<T> { T next(); }
通配符	?（无界）、? extends T（上界）、? super T（下界）
类型擦除	编译后泛型信息会被擦除，变为 Object
限制	不能使用基本类型、不能创建泛型数组、不能实例化泛型