Java泛型：代码世界的“万能钥匙”与“类型契约”

合集 - java(9)

1.MyBatis-Plus：简化 CRUD 操作的艺术2024-10-31 2.Java学习十七—反射机制：解锁代码的无限可能2024-11-03 3.MyBatis-Plus快速入门：从安装到第一个Demo2024-11-03 4.MyBatis-Plus条件构造器：构建安全、高效的数据库查询2024-11-04 5.深入 MyBatis-Plus 插件：解锁高级数据库功能2024-11-09 6.Java更新数据库报错：Data truncation: Cannot create a JSON value from a string with CHARACTER SET2024-11-23 7.探索Java动态代理的奥秘：JDK vs CGLIB02-04

8.Java泛型：代码世界的“万能钥匙”与“类型契约”02-23

9.高效开发助手：深入了解Hutool工具库02-23

一、关于泛型

1.1 简介

Java泛型自J2SE 5.0引入，彻底改变了开发者处理数据类型的方式，将类型安全与代码复用推向新高度。

Java 泛型（Generics）是 Java 5 引入的一个特性，允许在类、接口和方法中使用类型参数，使得代码更加通用、灵活、可重用，并且能提供更强的类型安全性。

dc295ff4-fcda-4395-b3bb-77c4f2332888

‍在 Java 中，泛型允许在定义类、接口或方法时使用类型参数，具体的类型在使用时再指定。泛型使得同一类或方法能够处理不同类型的数据，而无需编写多个版本的代码。

例如，使用泛型的集合类 List<T> 可以存储不同类型的元素，T 代表类型参数。

1.2 发展

Java 泛型（Generics）的发展历程可以追溯到 Java 语言的早期版本。下面是 Java 泛型的主要发展过程：

1. Java 语言初期（1.0 - 1.4）

在 Java 的早期版本中，Java 并没有提供泛型机制。开发者只能使用原始类型（如 Object）来实现代码的通用性，这导致了以下两个主要问题：

类型安全问题： 由于 Java 不支持泛型，开发者必须使用 Object 来表示任何类型，这导致了大量的类型转换错误，增加了出错的机会。
代码冗余： 开发者不得不编写多个版本的代码来处理不同类型的数据，这使得代码冗长且不易维护。

例如，早期集合类如 Vector 和 ArrayList 只能存储 Object 类型的元素，需要在取出元素时进行强制类型转换：

Vector vector = new Vector();
vector.add("Hello");
String str = (String) vector.get(0);  // 需要类型转换

2. Java 5（2004年发布） - 引入泛型

Java 5（J2SE 5.0，也叫做 "Tiger"）是引入泛型的关键版本。泛型成为 Java 的一项重要特性，它改变了 Java 语言的编程方式，使得类型安全性和代码可重用性得到了极大的提升。主要特性如下：

引入泛型语法： 使用 <> 表示类型参数，例如 List<String> 表示一个只能存储 String 类型的集合。
类型擦除机制： 泛型在编译时会被擦除（type erasure），即类型参数在编译后的字节码中不再保留具体类型信息。
通配符（Wildcard）与边界： 支持通配符（如 ?）和上界（extends）与下界（super）限定符，用于进一步限制泛型的类型范围。

// 引入泛型的例子
List<String> list = new ArrayList<>();
list.add("Hello");
String str = list.get(0);  // 无需强制类型转换

3. Java 6 和 Java 7（2006年和2011年发布）

Java 6 和 Java 7 主要对泛型进行了一些优化和增强，但没有引入重大变化。

Java 6（Java 5 后的修复与优化）： 在 Java 6 中，泛型得到了进一步的优化，减少了类型擦除带来的性能损失。
Java 7（引入钻石操作符 <> ）： Java 7 引入了钻石操作符（<>），它使得代码更加简洁，开发者不再需要显式地指定泛型类型，在编译时由编译器自动推断。

// Java 7 引入的钻石操作符
List<String> list = new ArrayList<>();  // 不再需要显式指定泛型类型

4. Java 8（2014年发布）

Java 8 在泛型方面没有引入新特性，但它引入了与泛型紧密相关的其他功能，特别是 Lambda 表达式 和 Stream API。这两个特性使得开发者能够更简洁地处理集合和泛型数据，尤其是在函数式编程风格的代码中。

Stream API：通过泛型支持，Stream API 可以对集合进行更复杂的操作，而无需显式地指定具体类型。

List<String> list = Arrays.asList("A", "B", "C");
list.stream().filter(s -> s.startsWith("A")).forEach(System.out::println);

5. Java 9 及以后（2017年发布，后续版本）

Java 9 引入了模块化（Project Jigsaw），但并未对泛型进行重大更新。此后，Java 10、Java 11 等版本也未对泛型进行大的改动。

然而，Java 10 引入了 局部变量类型推断（var ），可以让编译器自动推断局部变量的类型，包括泛型类型。这使得在某些场景下，泛型的使用更加灵活和简洁。

// Java 10 引入的局部变量类型推断
var list = new ArrayList<String>();  // 编译器推断类型

6. 泛型的局限性与挑战

尽管泛型在 Java 中带来了很多好处，但也存在一些局限性和挑战：

类型擦除： 泛型信息在编译时会被擦除，导致 Java 在运行时无法获取泛型的具体类型。这限制了某些操作，如无法通过反射获得泛型类型。
```
List<String> list = new ArrayList<>();
if (list instanceof List<String>) {  // 编译时错误，因为泛型信息被擦除
    // 代码无法运行
}
```
无法创建泛型数组： 由于类型擦除的机制，不能直接创建带有泛型类型的数组。例如，new T[] 是不允许的。
```
// 编译错误
T[] array = new T[10];  // 无法创建泛型数组
```

‍

1.3 功能特点

Java 泛型（Generics）是一种允许编写可以与多种数据类型一起工作的类、接口和方法的特性。它是在 Java 5 中引入的，旨在提高代码的类型安全性、可读性和重用性。以下是 Java 泛型的一些主要特点：

类型安全：
- 泛型提供编译时的类型检查，这意味着如果尝试将不兼容类型的对象插入到泛型集合中，编译器会报错，而不是在运行时抛出 ClassCastException 。
- 这种特性使得开发者能够在开发阶段捕获错误，而不需要等到程序运行时才发现问题。
消除强制类型转换：
- 使用泛型可以减少或完全避免显式的类型转换。例如，在没有使用泛型的情况下，从集合中获取元素通常需要进行强制类型转换；而在使用了泛型之后，这些转换是自动完成的，并且是隐式的。
向后兼容：
- 泛型被设计为向后兼容的，因此现有的非泛型代码可以在新的支持泛型的环境中继续工作。这种兼容性是通过类型擦除实现的，即在编译期移除所有泛型类型信息。
通配符：
- 泛型支持通配符 ? 来表示未知类型。这允许编写更加灵活的方法签名，比如接受任意类型的参数列表而不必指定具体的类型。
有界类型参数：
- 泛型允许定义有界的类型参数，这意味着你可以限制传入的类型必须是某个特定类型或其子类。例如，你可以定义一个泛型方法只接受实现了 Comparable 接口的类型作为参数。
类型擦除：
- 在Java中，泛型信息在编译时被移除，这个过程被称为类型擦除。这意味着泛型类型参数在运行时并不存在，所有的泛型类型都会被替换为其上限类型（通常是 Object），除非指定了下限。
泛型不能用于基本数据类型：
- 泛型只能用于引用类型，如 Integer, String, 自定义类等，而不能直接用于基本数据类型如 int, char, boolean 等。不过，由于自动装箱/拆箱机制的存在，可以直接使用包装类来间接地处理基本数据类型。
泛型类和泛型方法：
- 泛型不仅可以应用于类，也可以应用于单独的方法。这意味着你可以在不改变整个类的前提下，使单个方法具有泛型能力。
性能提升：
- 使用泛型减少了不必要的装箱和拆箱操作，特别是在处理集合时，这可以带来一定的性能增益。
复用性和灵活性：
- 泛型提高了代码的复用性，因为相同的逻辑可以适用于多种不同的数据类型，同时保持了类型的安全性。

‍

二、泛型语法

泛型类：指定类的类型参数。
泛型方法：指定方法的类型参数。
通配符（Wildcard） ：用于表示不确定的类型。

‍

2.1 泛型类

使用泛型定义类或接口时，需要在类名后面加上尖括号 < >，并在其中指定类型参数。

类型参数通常使用大写字母表示（如：T, E, K, V等）。常用T表示，是Type的缩写。

‍

示例

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

    public T getValue() {
        return value;
    }

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

使用泛型类时，指定实际类型：

Box<Integer> intBox = new Box<>();
intBox.setValue(100);
System.out.println(intBox.getValue()); // 输出100

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

‍

2.2 泛型接口

接口定义类型参数，实现类需指定具体类型。

‍

示例

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

// 实现类
public class StringList implements List<String> {
    private ArrayList<String> elements = new ArrayList<>();

    @Override
    public void add(String element) {
        elements.add(element);
    }

    @Override
    public String get(int index) {
        return elements.get(index);
    }
}

‍

2.3 泛型方法

泛型方法是指在方法中使用类型参数。它允许在方法中灵活地指定类型。

‍

示例

泛型方法是指在方法中使用类型参数。它允许在方法中灵活地指定类型。

public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

调用时可以传入不同类型的数组：

Integer[] intArray = {1, 2, 3};
String[] strArray = {"A", "B", "C"};

printArray(intArray); // 输出 1 2 3
printArray(strArray); // 输出 A B C

‍

package org.example.Generics;

public class MethodTest {

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

        MethodTest test = new MethodTest();
        test.printArray(intArray);
        test.printArray(strArray);
    }


    public <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

}

‍

2.4 通配符（Wildcard）

泛型的通配符 ? 用于增强灵活性，常见于方法参数或返回值。

? extends T：表示类型是 T 或 T 的子类型。
? super T：表示类型是 T 或 T 的父类型。
?：表示未知类型。

‍

1. 无界通配符 `<?>`

匹配任意类型，但只能读取数据，无法写入。

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

‍

2. 上界通配符 `<? extends T>`

接受 T 或其子类型，适合读取数据（生产者）。

public double sum(List<? extends Number> list) {
    double sum = 0;
    for (Number num : list) {
        sum += num.doubleValue();
    }
    return sum;
}

‍

3. 下界通配符 `<? super T>`

接受 T 或其父类型，适合写入数据（消费者）。

public void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 5; i++) {
        list.add(i);
    }
}

‍

示例

import java.util.List;

public class WildcardExample {

    // 方法1：无界通配符 ?，表示可以接收任何类型的 List
    public static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }

    // 方法2：上界通配符 ? extends T，表示接受 T 类型及其子类
    public static void printUpperBoundedList(List<? extends Number> list) {
        for (Number num : list) {
            System.out.println(num);
        }
    }

    // 方法3：下界通配符 ? super T，表示接受 T 类型及其父类
    public static void addToList(List<? super Integer> list) {
        list.add(10);  // 只能添加 Integer 类型及其子类类型的元素
    }

    public static void main(String[] args) {
        // 示例 1：无界通配符
        List<String> stringList = List.of("Apple", "Banana", "Cherry");
        printList(stringList);

        // 示例 2：上界通配符
        List<Integer> integerList = List.of(1, 2, 3, 4);
        List<Double> doubleList = List.of(1.1, 2.2, 3.3);
        printUpperBoundedList(integerList);
        printUpperBoundedList(doubleList);

        // 示例 3：下界通配符
        List<Number> numberList = List.of(1, 2.5, 3);
        addToList(numberList);
        System.out.println(numberList);
    }
}

‍

2.5 类型参数边界（Bounded Type Parameters）

语法：使用 extends 约束类型参数的范围（可以是类或接口）。
示例：

// 约束 T 必须是 Number 或其子类
public class NumericBox<T extends Number> {
    private T number;

    public double getSquare() {
        return number.doubleValue() * number.doubleValue();
    }
}

// 使用
NumericBox<Integer> intBox = new NumericBox<>(); // 合法
NumericBox<String> strBox = new NumericBox<>();  // 编译错误！

‍

2.6 类型擦除（Type Erasure）

Java 泛型在编译后会擦除类型信息，替换为 Object 或上限类型，以保证与旧版本兼容。

// 编译前
List<String> list = new ArrayList<>();
// 编译后（类型擦除）
List list = new ArrayList(); // 实际存储 Object

‍

2.7 自定义泛型—多个类型参数

在Java中，当你定义一个泛型类、接口或方法时，可以使用多个类型参数。每个类型参数都被称为一个“标识符”，它代表了某个未知的类型，并且可以在类、接口或方法内部用于指定变量、返回值类型或参数类型。

多个类型参数的语法

当你需要使用多个类型参数时，你只需在尖括号< >内列出这些类型参数，并用逗号分隔它们。例如：

public class TwoTypePair<A, B> {
    private A first;
    private B second;

    public TwoTypePair(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public A getFirst() {
        return first;
    }

    public B getSecond() {
        return second;
    }
}

在这个例子中，TwoTypePair 类有两个类型参数 A 和 B，分别用于表示两个成员变量 first 和 second 的类型。

‍

示例

你可以这样创建 TwoTypePair 的实例：

TwoTypePair<String, Integer> pair1 = new TwoTypePair<>("Hello", 42);
TwoTypePair<Double, Boolean> pair2 = new TwoTypePair<>(3.14, true);

在这里，pair1 的 first 是 String 类型，而 second 是 Integer 类型；pair2 的 first 是 Double 类型，而 second 是 Boolean 类型。

‍

标识符命名惯例

虽然你可以为类型参数使用任何合法的Java标识符，但通常推荐使用单个大写字母来表示类型参数。常见的约定包括：

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

当然，如果你有多个类型参数并且它们的意义不同，也可以使用更有描述性的名称。比如在一个处理数据流的API中，可能会看到这样的定义：

public interface DataStreamProcessor<InputType, OutputType> {
    OutputType process(InputType input);
}

这里 InputType 和 OutputType 更加具体地反映了它们所代表的数据类型。

‍

有界类型参数

有时你可能希望限制某些类型参数只能是某种特定类型的子类型。这可以通过有界类型参数实现。例如：

public class NumericBox<T extends Number> {
    private T value;

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

    public T getValue() {
        return value;
    }
}

这里的 T extends Number 表明 T 只能是 Number 类型或者其子类型（如 Integer, Double 等）。

‍

使用多个类型参数可以帮助你构建更加通用和灵活的代码结构。通过遵循良好的命名惯例并合理利用有界类型参数，你可以确保你的泛型代码既易于理解和维护，又能提供必要的类型安全性。

请注意，尽管你可以为类型参数使用任意有效的标识符，但为了保持代码的清晰性和一致性，建议遵循上述的命名惯例。此外，当使用多个类型参数时，应该确保它们之间没有混淆，并且每个参数都有明确的作用范围和意义。

‍

三、总结

Java泛型不仅重塑了类型安全的编程范式，更以类型擦除的巧妙设计实现了新旧代码的无缝兼容。尽管其运行时类型信息缺失带来了些许限制，但泛型在集合框架、API设计及代码复用上的价值无可替代。未来，随着Valhalla项目对基本类型泛型（如List<int>）和值类型的支持，Java泛型有望进一步突破性能瓶颈，为开发者提供更高效、更灵活的工具。掌握泛型，意味着在类型安全的基石上，构建出简洁、健壮且面向未来的高质量代码。