Java泛型

什么是泛型

泛型是一种在编程中广泛使用的概念，特别是在面向对象编程中。它允许开发者在编写代码时使用类型参数，这些参数在实际使用时才会被具体的类型所替换。简单来说，泛型就是将类型参数化，使得一个类或方法能够操作多种数据类型，而不仅仅是预先定义的某一种或几种类型。泛型的本质是参数化类型，这意味着所操作的数据类型被指定为一个参数，延迟到代码运行时才确定具体的类型。

为什么使用泛型

泛型的引入主要是为了提高代码的灵活性和复用性，同时保证类型安全。以下是泛型的几个主要优势：

类型安全

使用泛型可以在编译时检查类型错误，防止在运行时出现ClassCastException。这意味着你可以在代码编写阶段发现潜在的类型转换错误，而不是等到程序运行时才发现。

代码复用

通过使用泛型，你可以编写更加通用的代码，而无需为不同的数据类型编写多个版本。例如，一个通用的栈（Stack）类可以通过泛型处理任何类型的数据，而无需为每种数据类型（如int、String等）创建单独的类。

灵活性

泛型允许你编写更加灵活和可扩展的代码。你可以定义一个泛型类或方法，使其适用于多种不同的类型，而无需了解这些类型的具体细节。

为了更好地理解泛型的使用场景，让我们从一个简单的例子开始。假设你需要创建一个只存储int类型数据的栈（Stack）。你可能会这样定义：

使用泛型后

虽然这个栈类可以很好地处理int类型的数据，但如果你需要一个存储String或其他类型的栈，你就必须重新创建一个类似的类。这显然会增加代码的冗余性和维护成本。此时，引入泛型就显得尤为重要。使用泛型后，你可以创建一个可以存储任何类型的通用栈类。

如何使用泛型

泛型类

泛型类是指在类定义时通过类型参数来指定类中某些属性的类型。泛型类的定义语法如下：

class 类名称<泛型标识, 泛型标识, ...> {

    private 泛型标识 变量名;

    // 其他代码...

}

例如，一个通用的Box类可以存储任何类型的对象：

public class Box<T> {

    private T t;



    public void set(T t) {

        this.t = t;

    }



    public T get() {

        return t;

    }

}



// 使用泛型类

Box<Integer> integerBox = new Box<>();

integerBox.set(123);

Integer number = integerBox.get();



Box<String> stringBox = new Box<>();

stringBox.set("Hello World");

String str = stringBox.get();

在上述代码中，Box类是一个泛型类，T是一个类型参数，它可以代表任何类型。当你实例化Box类时，你需要指定具体的类型，如Integer或String。

泛型方法

泛型方法是指在调用方法时指定类型参数的方法。它们的定义通常出现在一个普通类中，并允许你在方法中使用未指定的类型。

public class Util {

    // 泛型方法 printArray

    public static <E> void printArray(E[] inputArray) {

        for (E element : inputArray) {

            System.out.printf("%s ", element);

        }

        System.out.println();

    }

}



// 使用泛型方法

Integer[] intArray = {1, 2, 3, 4, 5};

Util.printArray(intArray);



String[] stringArray = {"Hello", "World"};

Util.printArray(stringArray);

在这个例子中，printArray方法是一个泛型方法，它可以打印任何类型的数组。类型参数<E>在方法声明中指定，并用于定义方法参数的类型。

泛型接口

泛型接口与泛型类类似，只不过它定义了一个或多个类型参数作为接口的一部分。这些类型参数在接口的实现类中被具体化。

public interface Pair<K, V> {

    public K getKey();

    public V getValue();

}



// 实现泛型接口

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;

    }



    @Override

    public K getKey() {

        return key;

    }



    @Override

    public V getValue() {

        return value;

    }

}



// 使用泛型接口

Pair<String, Integer> p = new OrderedPair<>("Even", 8);

在这个例子中，Pair接口是一个泛型接口，OrderedPair类实现了这个接口，并为类型参数K和V提供了具体的类型。

类型通配符

类型通配符（Wildcard Types）用于泛型中，以提高代码的灵活性。通配符的使用场景包括但不限于协变和逆变：

1. ? 表示未知类型。
2. ? extends T 表示未知的类型，它是T的子类或T本身。
3. ? super T 表示未知的类型，它是T的父类或T本身。

List<?> wildcardList = new ArrayList<String>();

List<? extends Number> numList = new ArrayList<Integer>();

// numList.add(new Integer(10)); // 编译错误



List<? super Integer> intSuperList = new ArrayList<Number>();

intSuperList.add(new Integer(10)); // 正确

泛型的限制

泛型类、接口和方法可以有类型限制，以确保类型安全。例如：

public class Pair<K extends Comparable<K>, V> {

    // 类实现

}

在这个例子中，类型参数K必须实现Comparable<K>接口，确保K是可比较的。

总结

泛型是Java中非常强大的特性，它提供了编译时的类型检查，增加了代码的复用性和安全性。理解并熟练使用泛型，对于编写高质量的Java代码至关重要。通过掌握泛型类、泛型方法、泛型接口以及类型通配符的使用，你可以编写出更为通用和灵活的代码。