Java泛型编程

最新推荐文章于 2024-07-16 08:30:00 发布

isuss

最新推荐文章于 2024-07-16 08:30:00 发布

阅读量311

点赞数

文章标签： java

本文链接：https://blog.csdn.net/isuss/article/details/130855217

版权

Java中的泛型是一种强大的语言特性，可以帮助我们写出更加安全和可复用的代码。本文将详细介绍Java中的泛型，包括什么是泛型、为什么需要泛型、如何泛型编程、类型擦除等多个方面的内容。

什么是泛型？

泛型是Java中的一种特性，它允许我们定义一种类型，在使用时再指定具体的类型。例如，我们可以定义一个 List 类型，然后在使用时指定具体的元素类型，例如 List<String>、List<Integer> 等。

Java中的泛型是通过参数化类型来实现的，我们可以在定义类、接口、方法时，使用参数来表示类型变量，并在使用时指定具体的类型。

例如，下面是一个使用泛型的例子：

public class Box<T> {
    private T value;
    
    public Box(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

在上述代码中，我们定义了一个 Box 类，它使用类型变量 T 表示要存储的值的类型。在使用时，我们可以创建一个 Box 对象，并指定具体的类型，例如：

Box<String> stringBox = new Box<>("Hello, World!");
Box<Integer> intBox = new Box<>(123);

在上述代码中，我们分别创建了一个存储字符串和一个存储整数的 Box 对象。

为什么需要泛型？

泛型的引入主要是为了解决类型安全和代码复用的问题。

在使用非泛型的集合类型时，我们往往需要使用强制类型转换来将元素转换为正确的类型。例如，下面是一个使用非泛型的 List 类型的例子：

List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);

在上述代码中，我们创建了一个 List 对象，然后添加了两个字符串元素。由于 List 类型是非泛型的，因此在获取元素时需要进行强制类型转换。然而，如果我们不小心将一个非字符串类型的元素添加到了列表中，那么在获取元素时就会出现类型转换异常，从而导致程序崩溃。这种情况在编译时是无法检测到的，只有在运行时才能发现。

使用泛型可以避免这种类型安全问题，因为泛型会在编译时进行类型检查，从而确保只能添加指定类型的元素。

另外，泛型还可以提高代码的复用性。例如，我们可以定义一个通用的 Box 类型，用于存储任意类型的值，而不需要为每种类型都定义一个独立的类。这样，我们就可以将相同的代码应用于多种类型，并且不需要担心类型安全问题。

如何泛型编程？

在Java中，我们可以使用泛型来编写泛型类、泛型接口和泛型方法。

泛型类

泛型类是指在类的声明中使用类型变量的类。例如，前面提到的 Box 类就是一个泛型类。我们可以使用泛型类来创建一个存储任意类型值的容器，例如：

public class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

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

在上述代码中，我们使用类型变量 T 来表示存储的值的类型。然后，在创建 Box 对象时，我们可以指定具体的类型，例如：

Box<String> stringBox = new Box<>("Hello, World!");
Box<Integer> intBox = new Box<>(123);

在上述代码中，我们创建了一个存储字符串和一个存储整数的 Box 对象。

泛型接口

泛型接口是指在接口的声明中使用类型变量的接口。例如，下面是一个使用泛型接口的例子：

public interface List<E> {
    void add(E element);
    E get(int index);
}

在上述代码中，我们使用类型变量 E 来表示列表中存储的元素类型。然后，在实现 List 接口时，我们需要指定具体的元素类型。

泛型方法

泛型方法是指在方法的声明中使用类型变量的方法。例如，下面是一个使用泛型方法的例子：

public class Utils {
    public static <T> T first(List<T> list) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        return list.get(0);
    }
}

在上述代码中，我们使用类型变量 T 来表示列表中存储的元素类型。然后，在定义 first 方法时，我们使用 <T> 来声明 T 是一个类型参数。在方法体中，我们可以使用 T 来指定列表的元素类型。

在调用 first 方法时，我们需要指定列表的元素类型，例如：

List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");
String first = Utils.first(stringList);

在上述代码中，我们将一个存储字符串的列表传递给 first 方法，然后指定其元素类型为 String。由于 first 方法是泛型方法，因此它可以根据传递的列表自动推断出元素类型 T，而不需要显式指定。

类型擦除是怎么回事？

Java中的泛型是通过类型擦除来实现的。类型擦除是指在编译时，将使用泛型的代码中的类型信息擦除掉，将泛型类型转换为实际类型，从而在运行时不再使用泛型类型。

例如，下面是一个使用泛型的例子：

public class Box<T> {
    private T value;
    
    public Box(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

Box<String> stringBox = new Box<>("Hello, World!");
String value = stringBox.getValue();

在上述代码中，我们定义了一个泛型类 Box，它使用类型变量 T 表示存储的值的类型。然后，我们创建了一个存储字符串的 Box 对象，并从中获取了存储的值。

在编译时，编译器会将使用泛型的代码中的类型信息擦除掉，并将泛型类型转换为实际类型。在上述代码中，编译器会将 Box<String> 转换为 Box，并将 T 转换为 String。因此，在运行时，Box 对象中存储的是一个字符串，而不是一个泛型类型。

类型擦除的实现方式是在编译时将泛型类型转换为 Object 类型，并插入必要的强制类型转换。这样，可以在运行时保证类型安全，同时避免了由于泛型类型信息导致的性能问题。

然而，类型擦除也带来了一些限制。由于在运行时无法获取泛型类型信息，因此在某些情况下，可能无法进行某些操作。例如，无法创建一个泛型类型的实例，例如 new T()，因为在运行时无法确定 T 的实际类型。

另外，由于类型擦除的存在，可能导致某些类型信息丢失，从而导致泛型类型与原始类型之间的不兼容。例如，List<String> 和 List<Integer> 在编译时都会被擦除为 List，因此它们在运行时无法区分。这也是为什么 Java 中无法创建泛型数组的原因，因为在数组创建时需要明确指定元素类型，而泛型类型在运行时无法确定。

为了解决这些限制，Java中引入了一些工具类和语法糖，例如 TypeToken 和泛型通配符等。

TypeToken

TypeToken 是 Google Guava 中的一个工具类，它可以帮助我们在运行时获取泛型类型的信息。

首先需要引入 Guava 库的依赖，例如：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

下面是一个使用 TypeToken 的例子：

public class Box<T> {
    private T value;
    
    public Box(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

Box<String> stringBox = new Box<>("Hello, World!");
TypeToken<Box<String>> token = new TypeToken<Box<String>>() {};
Type type = token.getType();
System.out.println(type); // 输出 "Box<java.lang.String>"

在上述代码中，我们使用 TypeToken 来获取 Box<String> 的类型信息。首先，我们创建了一个存储字符串的 Box 对象。然后，我们使用 TypeToken 来获取 Box<String> 的类型信息，并将其存储在 Type 类型的变量中。最后，我们将获取到的类型信息输出到控制台上。

需要注意的是，由于 Java 的类型擦除机制，TypeToken 只能在对象创建时获取泛型类型的信息，并且需要使用匿名内部类来获取正确的类型信息。

泛型通配符

泛型通配符是一种语法糖，它可以帮助我们在泛型类型中使用不同的类型变量。例如，下面是一个使用泛型通配符的例子：

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

List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");
printList(stringList);

在上述代码中，我们定义了一个 printList 方法，它接受一个 List 类型的参数，并使用泛型通配符来表示列表中的元素可以是任意类型。然后，我们将一个存储字符串的列表传递给 printList 方法，并输出列表中的每个元素。

需要注意的是，由于泛型通配符表示列表中的元素可以是任意类型，因此在使用时无法对列表进行添加操作。例如，下面的代码是无法通过编译的：

public static void addToList(List<?> list, Object element) {
    list.add(element); // 编译错误：无法添加元素到通配符类型的列表中
}

List<String> stringList = new ArrayList<>();
addToList(stringList, "Hello"); // 编译错误：无法将元素添加到通配符类型的列表中

在上述代码中，我们定义了一个 addToList 方法，它接受一个 List 类型的参数和一个元素，并试图将元素添加到列表中。由于列表的类型是通配符类型，因此在编译时会出现无法添加元素的编译错误。

为了解决这个问题，我们可以使用有限制的通配符来限制列表类型的上下界。例如，下面是一个使用有限制的通配符的例子：

public static void addToList(List<? super String> list, String element) {
    list.add(element);
}

List<Object> objectList = new ArrayList<>();
addToList(objectList, "Hello");

在上述代码中，我们使用有限制的通配符 <? super String> 来表示列表中的元素必须是 String 类型或其父类。然后，我们将一个存储字符串的列表传递给 addToList 方法，并将其添加到一个存储 Object 的列表中。

需要注意的是，使用有限制的通配符可能会导致代码可读性降低，因为在使用时需要明确指定上界类型，并且可能会出现类型转换问题。因此，在使用时需要根据实际情况选择合适的泛型类型。