什么是Java泛型？主要应用场景有哪些？

什么是泛型？

在介绍 Java 的泛型之前，我们需要先了解一下什么是泛型。泛型（Generics）是 Java 5 中新增的特性，可以让我们编写更加通用、可重用的代码。通过使用泛型，我们可以在编译时期检查数据类型的合法性，并避免出现一些常见的运行时错误。

简单来说，泛型就是将具体的数据类型作为参数传递给类或方法，从而实现代码的重用和类型安全。因此，使用泛型可以提高程序的可读性、可维护性和可靠性。

泛型的优点

使用泛型能够带来以下几个主要的优点：

• 类型安全：泛型可以在编译时期检查数据类型的合法性，避免出现一些常见的运行时错误，如 ClassCastException。
• 可重用性：泛型可以让我们编写更加通用、可重用的代码，减少代码的重复量。
• 代码清晰：通过使用泛型，可以使代码更加清晰、易懂，降低代码阅读的难度。
• 性能提升：由于泛型避免了不必要的类型转换，所以在一定程度上可以提高程序的性能。

泛型的基本应用

Java 的泛型主要应用于以下三个方面：

泛型类

泛型类是指在定义类的时候使用泛型参数。通过在类的定义中使用泛型参数，可以将具体的数据类型作为参数传递给类，并在类内部使用这些数据类型。

public class MyGenericClass<T> {
    private T value;

    public MyGenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return this.value;
    }

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

上面的代码定义了一个泛型类 MyGenericClass，其中的泛型参数 T 可以接收任何数据类型。在创建 MyGenericClass 对象时，可以传入具体的数据类型作为参数。例如：

MyGenericClass<String> stringObj = new MyGenericClass<>("Hello, World");
MyGenericClass<Integer> intObj = new MyGenericClass<>(123);

由于使用了泛型，stringObj 对象的类型是 MyGenericClass<String>，而 intObj 对象的类型是 MyGenericClass<Integer>。因此，在调用 getValue 方法时，stringObj 对象将返回一个 String 类型的值，而 intObj 对象将返回一个 Integer 类型的值。

泛型方法

泛型方法是指在方法的返回值前使用泛型参数。通过在方法的定义中使用泛型参数，可以将具体的数据类型作为参数传递给方法，并在方法内部使用这些数据类型。

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

上面的代码定义了一个泛型方法 printArray，其中的泛型参数 T 可以接收任何数据类型。在调用 printArray 方法时，可以传入具体的数据类型作为参数。

String[] stringArray = {"Hello", "World"};
Integer[] intArray = {1, 2, 3};
MyGenericMethod.<String>printArray(stringArray);
MyGenericMethod.<Integer>printArray(intArray);

由于使用了泛型，上面的代码可以重用同一个 printArray 方法来打印不同类型的数组。例如，printArray(stringArray) 方法将打印出字符串数组中的所有元素，而 printArray(intArray) 方法将打印出整数数组中的所有元素。

泛型接口

泛型接口是指在定义接口的时候使用泛型参数。通过在接口的定义中使用泛型参数，可以将具体的数据类型作为参数传递给接口，并在实现接口的类中使用这些数据类型。

public interface MyGenericInterface<T> {
    T getValue();
    void setValue(T value);
}

上面的代码定义了一个泛型接口 MyGenericInterface，其中的泛型参数 T 可以接收任何数据类型。在实现 MyGenericInterface 接口时，需要指定一个具体的数据类型。

public class MyGenericClass<T> implements MyGenericInterface<T> {
    private T value;

    public MyGenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return this.value;
    }

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

上面的代码实现了 MyGenericInterface 接口，并使用泛型参数 T 作为返回值和参数的类型。由于使用了泛型，MyGenericClass 类可以重用同样的实现来处理不同类型的数据。

泛型的高级应用

除了基本的泛型应用外，Java 还支持一些高级的泛型应用。这些高级泛型包括通配符、类型擦除、反射等。

通配符

通配符（Wildcard）是指在泛型类型参数中使用问号 ? 来表示任意类型。使用通配符可以使泛型类型接受任何类型的参数。

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

上面的代码定义了一个方法 processList，其中的泛型参数使用了通配符 ?。这个方法可以接受任何类型的 List 类型参数，并遍历其中的元素。

需要注意的是，使用通配符表示任意类型的参数时，不能在其中加入任何元素，因为我们无法确定这些元素的具体类型。

类型擦除

Java 的泛型实现是通过类型擦除（Type Erasure）来实现的。类型擦除是指在编译时期，将泛型类型转换为普通类型。

public class MyGenericClass<T> {
    private T value;

    public MyGenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return this.value;
    }
}

上面的代码定义了一个泛型类 MyGenericClass，其中的泛型参数 T 可以接收任何数据类型。在编译时期，Java 会将这个泛型类转换为以下的普通类：

public class MyGenericClass {
    private Object value;

    public MyGenericClass(Object value) {
        this.value = value;
    }

    public Object getValue() {
        return this.value;
    }
}

由于类型擦除的存在，我们无法在运行时期获取泛型参数的实际类型信息。

MyGenericClass<String> stringObj = new MyGenericClass<>("Hello, World");
System.out.println(stringObj.getClass()); // 输出: class MyGenericClass

上面的代码中，stringObj 对象的实际类型是 MyGenericClass<String>，但在运行时期，我们只能获取到其擦除后的类型 MyGenericClass。

反射

Java 的反射机制可以让我们在运行时期获取类的信息，并动态地调用类的方法或构造函数。使用反射机制可以绕过泛型类型擦除的限制，从而获取到泛型参数的实际类型信息。

public class MyGenericClass<T> {
    private T value;

    public MyGenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return this.value;
    }
}

上面的代码定义了一个泛型类 MyGenericClass，其中的泛型参数 T 可以接收任何数据类型。我们可以通过反射机制来获取这个泛型参数的实际类型。

MyGenericClass<String> stringObj = new MyGenericClass<>("Hello, World");
Class<?> clazz = stringObj.getClass();
ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
Type[] types = parameterizedType.getActualTypeArguments();

for (Type type : types) {
    System.out.println(type.getTypeName()); // 输出: java.lang.String
}

上面的代码中，我们先获取到 stringObj 对象的实际类型 MyGenericClass<String>，然后通过反射机制获取这个类型的父类 MyGenericClass 的泛型参数类型。由于 Java 的泛型实现是基于类型擦除的，因此在运行时期，我们无法直接获取到泛型类型参数的实际类型。但是，通过获取父类的泛型参数类型，我们可以间接地获得泛型参数的实际类型。

总结

本文介绍了 Java 的泛型特性，包括基本的泛型应用和高级的泛型应用。泛型可以提高程序的可读性、可维护性和可靠性，并可以使代码更加通用、易懂。然而，使用泛型时也需要注意其在编译时期和运行时期的差异，并避免出现一些常见的运行时错误。