Java 泛型详解：全面掌握类型安全与灵活性的利器

Java 泛型详解：全面掌握类型安全与灵活性的利器

Java 泛型是自 Java 5 引入的一项关键特性，旨在提升代码的类型安全性和可复用性。泛型通过引入参数化类型，允许类、接口和方法操作具体类型的数据，而无需在定义时指定具体类型。本文将深入探讨 Java 泛型的基本概念、类型参数与界定、通配符的使用、泛型的限制与继承、类型擦除、桥方法、泛型数组的创建、反射中的泛型处理，以及泛型的高级用法。通过全面了解和掌握这些知识点，开发者可以编写出更加通用、灵活和安全的 Java 代码。

1. 泛型的基本概念

1.1 泛型类

泛型类允许在类定义中使用参数化类型。这意味着类可以操作某种特定类型的数据，而在实例化类时才指定这种类型。

public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

使用泛型类时，具体的类型参数在实例化时确定：

Box<Integer> integerBox = new Box<>();
integerBox.set(10);
Integer value = integerBox.get();

1.2 泛型接口

类似于泛型类，泛型接口允许在接口定义中使用参数化类型。

public interface Container<T> {
    void add(T item);
    T get(int index);
}

实现泛型接口：

public class Box<T> implements Container<T> {
    private List<T> items = new ArrayList<>();

    @Override
    public void add(T item) {
        items.add(item);
    }

    @Override
    public T get(int index) {
        return items.get(index);
    }
}

1.3 泛型方法

泛型方法使得方法可以独立于类而操作某种特定类型的数据。泛型方法的类型参数放在方法的返回类型之前。

public class Util {
    public static <T> void printArray(T[] inputArray) {
        for (T element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
}

调用泛型方法：

Integer[] intArray = {1, 2, 3, 4, 5};
Util.printArray(intArray);

2. 类型参数和类型参数界定

2.1 类型参数

类型参数是泛型中的占位符，通常用单个大写字母表示：

• E：元素（Element）
• K：键（Key）
• V：值（Value）
• N：数字（Number）
• T：类型（Type）

2.2 类型参数的界定

类型参数可以被限定，使得它只能是某个类或接口的子类或实现类。

public class Box<T extends Number> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

这样，Box 类的实例只能接受 Number 类型及其子类作为类型参数。

多重界定
类型参数可以有多个边界，使用 & 符号进行分隔。

public class Box<T extends Number & Comparable<T>> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

3. 通配符

通配符用于泛型中的未知类型。

3.1 无界通配符

无界通配符 <?> 表示未知类型，通常用于只读访问的场景。

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

调用方法：

List<String> stringList = Arrays.asList("one", "two", "three");
printList(stringList);

3.2 上界通配符

上界通配符 <? extends T> 表示类型是 T 或 T 的子类，通常用于读取的场景。

public void process(List<? extends Number> list) {
    for (Number number : list) {
        System.out.println(number.doubleValue());
    }
}

调用方法：

List<Integer> integerList = Arrays.asList(1, 2, 3);
process(integerList);

3.3 下界通配符

下界通配符 <? super T> 表示类型是 T 或 T 的超类，通常用于写入的场景。

public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

调用方法：

List<Number> numberList = new ArrayList<>();
addNumbers(numberList);

4. 泛型的限制

• 不能使用基本类型作为类型参数，例如 Box 是非法的，必须使用包装类 Box。
• 静态成员中不能使用类型参数，因为类型参数是在实例化时确定的，而静态成员与实例无关。
• 实例创建时不能使用类型参数，例如 new T() 是非法的，因为类型参数在运行时被擦除。
• 泛型数组不能直接创建，例如 new T[10] 是非法的。可以通过创建 Object 数组并进行类型转换来间接实现：

T[] array = (T[]) new Object[10];

5. 泛型与继承

泛型支持继承，但需要注意类型兼容性。

class Parent<T> { }
class Child<T> extends Parent<T> { }

Parent<String> parent = new Parent<>();
Child<String> child = new Child<>();

但是，不能将 Parent 赋值给 Parent，因为泛型是不协变的。

泛型的协变和逆变
虽然泛型类型参数是不协变的，但是可以使用通配符来实现协变和逆变：

List<? extends Number> covariantList = new ArrayList<Integer>(); // 协变
List<? super Integer> contravariantList = new ArrayList<Number>(); // 逆变

6. 类型擦除

Java 的泛型在编译时会进行类型擦除，以保证与旧版本的 Java 兼容。类型擦除后，所有泛型信息都会被移除，替换为其限定的类型或 Object。

public class Box<T> {
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

类型擦除后相当于：

public class Box {
    private Object t;
    public void set(Object t) { this.t = t; }
    public Object get() { return t; }
}

7. 桥方法

在类型擦除过程中，为了保证类型安全，编译器会生成桥方法。例如：

class Parent<T> {
    public T method(T t) { return t; }
}

class Child extends Parent<String> {
    public String method(String t) { return t; }
}

生成桥方法后：

class Child extends Parent<String> {
    public String method(String t) { return t; }
    public Object method(Object t) { return method((String) t); } // 桥方法
}

8. 泛型数组

由于类型擦除的限制，Java 不支持直接创建泛型数组。可以通过创建 Object 数组并进行类型转换来间接实现：

T[] array = (T[]) new Object[10];

9. 泛型的使用场景

泛型被广泛应用于 Java 的集合框架、定义自定义泛型类和方法、类型参数界定等场景。

• 集合框架：如 List、Set、Map<K, V> 等。
• 自定义泛型类和方法：提高代码的复用性和类型安全。
• 类型参数界定：如 Comparable 接口。

10. 泛型与反射

在使用反射时，泛型类型会被擦除为原始类型，无法直接获取泛型类型的信息。但可以通过反射获取泛型的实际类型参数。

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class GenericTypeDemo<T> {
    public static void main(String[] args) {
        GenericTypeDemo<String> demo = new GenericTypeDemo<>();
        Type type = demo.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

11. 泛型擦除后的副作用

类型擦除会导致一些潜在的问题，例如类型转换异常和类型安全问题。

public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");

        Box rawBox = stringBox; // 允许的，但是会有类型安全问题
        rawBox.set(10); // 运行时异常：ClassCastException
    }
}

12. 泛型的高级用法

12.1 泛型的嵌套

泛型类型可以嵌套使用，例如 Map<K, List>。

Map<String, List<Integer>> map = new HashMap<>();

12.2 类型推断

Java 7 引入了菱形操作符 <>，使得编译器可以推断泛型的类型参数，从而减少冗长的代码。

List<String> list = new ArrayList<>();

12.3 泛型的类型推导

Java 8 引入了更强大的类型推导机制，允许在方法调用中推导出类型参数。

public static <T> List<T> emptyList() {
    return new ArrayList<T>();
}

List<String> list = emptyList();

13. 总结

Java 泛型极大地提高了代码的类型安全性和可复用性，使得代码更加通用和灵活。理解并掌握泛型的使用对于编写高质量的 Java 代码至关重要。通过深入了解泛型的各种特性和限制，可以更好地利用泛型来编写类型安全、灵活和高效的代码。