Java泛型

介绍

Java泛型（Generics）是Java语言中一项强大的特性，它允许你在定义类、接口和方法时使用类型参数。通过泛型，你可以编写更通用、更灵活的代码，同时提高代码的类型安全性。泛型的主要目的是在编译时检测类型错误，而不是在运行时。

在没有泛型的情况下，你可能需要为不同类型编写几乎相同的代码，这不仅增加了代码量，还容易引入类型转换错误。泛型通过参数化类型解决了这个问题。

泛型的基本语法

泛型类

泛型类是指使用类型参数的类。你可以通过在类名后面添加尖括号 <T> 来定义一个泛型类，其中 T 是类型参数。

java

public class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}

在这个例子中，Box 类可以存储任何类型的对象。你可以通过以下方式使用这个泛型类：

java

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello, Generics!");
System.out.println(stringBox.getItem()); // 输出: Hello, Generics!

Box<Integer> integerBox = new Box<>();
integerBox.setItem(123);
System.out.println(integerBox.getItem()); // 输出: 123

泛型方法

泛型方法是指在方法中使用类型参数。你可以在方法的返回类型之前定义类型参数。

java

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

你可以通过以下方式调用这个泛型方法：

java

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

printArray(intArray); // 输出: 1 2 3 4 5
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

Pair<String, Integer> pair = new OrderedPair<>("One", 1);
System.out.println(pair.getKey());   // 输出: One
System.out.println(pair.getValue()); // 输出: 1

泛型的实际应用场景

集合框架

Java集合框架（如 ArrayList, HashMap 等）是泛型最典型的应用场景之一。通过泛型，集合可以存储特定类型的对象，从而避免类型转换错误。

java

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Generics");
// list.add(123); // 编译错误，类型不匹配

for (String item : list) {
    System.out.println(item);
}

自定义数据结构

泛型还可以用于定义自定义的数据结构，如栈、队列等。通过泛型，这些数据结构可以处理任何类型的对象。

java

public class Stack<T> {
    private List<T> elements = new ArrayList<>();

    public void push(T item) {
        elements.add(item);
    }

    public T pop() {
        if (elements.isEmpty()) {
            throw new EmptyStackException();
        }
        return elements.remove(elements.size() - 1);
    }
}

你可以通过以下方式使用这个泛型栈：

java

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
System.out.println(stack.pop()); // 输出: 2
System.out.println(stack.pop()); // 输出: 1

总结

Java泛型是一项强大的特性，它允许你编写更通用、更灵活的代码，同时提高代码的类型安全性。通过泛型，你可以避免类型转换错误，减少代码重复，并提高代码的可读性和可维护性。

在实际开发中，泛型广泛应用于集合框架、自定义数据结构等场景。掌握泛型的使用方法，将有助于你编写更高质量的Java代码。

附加资源与练习

• 练习1：编写一个泛型方法 swap，用于交换数组中两个元素的位置。
• 练习2：创建一个泛型类 Pair，用于存储两个不同类型的对象，并实现 equals 和 hashCode 方法。
• 阅读：Java官方文档中的泛型教程。

提示

泛型是Java中一个非常重要的概念，建议你通过实际编码练习来加深理解。