跳到主要内容

泛型机制

什么是泛型？​

泛型（Generics）是 Java 5 引入的一项重要特性，它允许你在定义类、接口或方法时使用类型参数。通过泛型，你可以编写更通用、更安全的代码，同时避免类型转换的麻烦。

简单来说，泛型让你可以在编译时指定数据类型，而不是在运行时才确定。这使得代码更加灵活，同时减少了运行时类型转换的错误。

为什么需要泛型？​

在没有泛型之前，Java 程序员通常使用 Object 类型来实现通用代码。例如，一个可以存储任何类型对象的集合类：

java
List list = new ArrayList();
list.add("Hello");
list.add(123);
String str = (String) list.get(0); // 需要强制类型转换
int num = (int) list.get(1); // 需要强制类型转换

这种方式虽然灵活，但存在以下问题：

  1. 类型不安全：你可以在集合中存储任何类型的对象，但取出时需要手动进行类型转换，容易引发 ClassCastException。
  2. 代码冗余：每次取出对象时都需要进行类型转换，增加了代码的复杂性。

泛型的引入解决了这些问题。它允许你在编译时指定集合中存储的数据类型，从而避免了类型转换的麻烦。

泛型的基本语法​

泛型类​

泛型类是指具有一个或多个类型参数的类。类型参数在类名后的尖括号中定义。例如：

java
public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

在这个例子中，T 是一个类型参数，表示 Box 类可以存储任意类型的对象。你可以这样使用它：

java
Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");
String str = stringBox.getItem(); // 不需要类型转换

Box<Integer> intBox = new Box<>();
intBox.setItem(123);
int num = intBox.getItem(); // 不需要类型转换

泛型方法​

泛型方法是指具有一个或多个类型参数的方法。类型参数在方法返回类型前定义。例如：

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

你可以这样调用泛型方法：

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

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

泛型接口​

泛型接口与泛型类类似，允许你在接口中定义类型参数。例如：

java
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

实现泛型接口时，你可以指定具体的类型：

java
public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

泛型的实际应用​

集合框架中的泛型​

Java 集合框架（如 List、Set、Map）广泛使用了泛型。例如：

java
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
String firstElement = list.get(0); // 不需要类型转换

通过泛型，你可以确保集合中只能存储指定类型的对象，从而避免了类型转换的错误。

自定义泛型类​

假设你需要一个通用的 Pair 类来存储两个相关联的对象：

java
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() { return first; }
    public U getSecond() { return second; }
}

你可以这样使用它：

java
Pair<String, Integer> pair = new Pair<>("Age", 25);
System.out.println(pair.getFirst() + ": " + pair.getSecond()); // 输出: Age: 25

泛型的限制​

类型擦除​

Java 的泛型是通过类型擦除（Type Erasure）实现的。这意味着泛型类型信息在编译后会被擦除，运行时无法获取泛型的具体类型。例如：

java
List<String> list = new ArrayList<>();
System.out.println(list.getClass()); // 输出: class java.util.ArrayList

在这个例子中，list 的类型在运行时是 ArrayList，而不是 ArrayList<String>。

不能使用基本类型​

泛型类型参数必须是引用类型，不能是基本类型（如 int、char 等）。如果需要使用基本类型，可以使用对应的包装类（如 Integer、Character 等）。

java
List<int> list = new ArrayList<>(); // 错误
List<Integer> list = new ArrayList<>(); // 正确

总结​

泛型是 Java 中一个强大的特性，它允许你编写更通用、更安全的代码。通过泛型，你可以避免类型转换的麻烦，并在编译时捕获类型错误。泛型广泛应用于集合框架和自定义类中，是 Java 编程中不可或缺的一部分。

提示

如果你想进一步学习泛型的高级特性（如通配符、泛型边界等），可以参考 Java 官方文档或其他高级教程。

附加资源​