详解Java中的泛型

什么是泛型？

泛型是一种编程方式，它允许在编译时期定义接受不同类型的类、接口和方法。通过泛型，我们可以创建适用于多种类型的代码，这些代码可以避免类型转换，提高代码的可读性和重用性。

泛型的基本语法是在尖括号中声明类型参数，例如 List\<T>，其中 T 就是类型参数，表示可以接受任何类型。在实际使用时，需要将 T 替换为具体的类型，例如 List\<String>。

泛型类和泛型接口

在Java中，可以使用泛型来定义类和接口。一个泛型类或泛型接口可以有一个或多个类型参数，使用时需要传入具体的类型。举个例子：

public class Box<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

在上面的例子中，Box 是一个泛型类，T 是类型参数。Box可以被实例化为不同的类型，例如：

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

在使用时，T 将被替换为实际的类型，例如 String 或 Integer。

同样的，我们也可以定义泛型接口，定义如下：

public interface Comparator<T> {
    int compare(T o1, T o2);
}

上述示例中，Comparator 是一个泛型接口，T 是类型参数。在排序算法中，我们可以定义实现该接口的比较器，实现不同类型的比较。

泛型方法

除了泛型类和泛型接口外，Java中还支持泛型方法。泛型方法可以在普通类中定义，也可以在泛型类中定义，语法如下：

public class Utils {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在上面的例子中，printArray 是一个泛型方法，其类型参数为 T。在实际使用时，可以传入不同类型的数组，例如：

String[] strings = {"a", "b", "c"};
Integer[] integers = {1, 2, 3};
Utils.printArray(strings);
Utils.printArray(integers);

输出结果分别为：

a b c 
1 2 3 

泛型通配符

泛型通配符用于支持处理多个泛型类型的对象。在Java中，有两种泛型通配符：? 和 ? extends T。其中，? 表示不确定的类型，而 ? extends T 表示 T 的子类或本身。

假设有如下定义：

public class Box<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

我们现在有一个方法需要接受 Box 类的 List，但是 List 中的元素类型是不确定的。我们可以使用泛型通配符，定义如下：

public static void printBoxList(List<Box<?>> boxes) {
    for (Box<?> box : boxes) {
        System.out.println(box.getData());
    }
}

在上面的例子中，? 表示不确定的类型，可以接受任何类型的 Box。我们可以将任意类型的 Box 的 List 传入该方法中。

示例

下面是两个使用泛型的示例：

示例 1：泛型类的使用

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

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

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public S getSecond() {
        return second;
    }

    public void setSecond(S second) {
        this.second = second;
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> pair1 = new Pair<>("foo", 10);
        System.out.println(pair1.getFirst() + " " + pair1.getSecond());

        Pair<Double, String> pair2 = new Pair<>(3.14, "bar");
        System.out.println(pair2.getFirst() + " " + pair2.getSecond());
    }
}

在上面的示例中，Pair 是一个泛型类，它可以接受两个类型参数。通过创建泛型对象 Pair\<String, Integer> 和 Pair\<Double, String>，我们可以存储不同类型的值。

示例 2：泛型方法的使用

public class Utils {
    public static <T extends Comparable<T>> T max(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] integers = {1, 3, 2, 4, 5};
        System.out.println(Utils.max(integers));

        String[] strings = {"foo", "bar", "baz"};
        System.out.println(Utils.max(strings));
    }
}

在上面的示例中，Utils 类中的 max 方法是一个泛型方法，它接受一个泛型数组，使用 Comparable 接口进行比较。我们可以使用该方法获取一个数组中的最大值。通过传递不同类型的数组，例如 Integer 和 String 类型，我们可以获取不同类型的最大值。