Java泛型

1.介绍：

泛型（Generics）是指编程语言中一种抽象的数据类型，可以在代码编写时指定其类型，然后在编译时进行类型检查和类型安全的操作。通过使用泛型，可以将数据类型作为参数传递到类、方法、接口等定义中，从而实现更灵活、安全、可读性高的编程。泛型的出现使得我们能够在编译时检测类型错误，而不是在运行时才发现问题，从而提高了代码的可靠性。泛型还可以减少类型强制转换的代码，使代码更加简洁易读。在Java中，泛型被广泛应用于集合类（如ArrayList、HashMap等）和函数式编程中。

2.创建泛型类：

假设我们要创建一个通用的Pair类，该类具有两个成员变量，分别为first和second，它们可以是任何类型，如整数、字符串、布尔值等等。在不使用泛型的情况下，我们可能会这样定义Pair类：

public class Pair {
    private Object first;
    private Object second;

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

    public Object getFirst() {
        return first;
    }

    public Object getSecond() {
        return second;
    }
}

使用该类时，我们需要进行强制类型转换，如下所示:

Pair pair = new Pair(1, "hello");
int first = (int) pair.getFirst();
String second = (String) pair.getSecond();

这种方式存在一个问题，就是如果我们在获取first和second的时候类型不匹配，会发生运行时错误。为了解决这个问题，Java 引入了泛型，可以让我们在定义类时指定类型，如下所示：

public class Pair<T, U> {
    // 定义一个T型变量和U型变量
    // T和U可以理解为一种数据类型，类似于int、String……
    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;
    }
}

在使用该类时，我们可以指定具体类型，如下所示：

Pair<Integer, String> pair = new Pair<>(1, "hello");
int first = pair.getFirst();
String second = pair.getSecond();

这样就不需要进行强制类型转换，代码也更加安全和可读。

3.创建泛型方法：

创建一个泛型方法，需要在方法声明中使用尖括号（<>）来定义泛型类型参数，然后在方法体中使用该类型参数。

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

在上面的示例中，我们定义了一个名为printArray的泛型方法，使用了类型参数<T>。该方法接受一个泛型数组，并遍历打印其中的元素。使用该方法时，可以传递任何类型的数组作为参数，如：

Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };
String[] stringArray = { "hello", "world" };

printArray(intArray);
printArray(doubleArray);
printArray(stringArray);

在上面的示例中，我们创建了三个不同类型的数组并传递给了printArray方法，该方法会打印出各自的元素。注意，由于printArray是一个泛型方法，它可以接受不同类型的数组作为参数。

完整代码如下：

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

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

        System.out.print("Integer Array: ");
        printArray(intArray);

        System.out.print("Double Array: ");
        printArray(doubleArray);

        System.out.print("Character Array: ");
        printArray(charArray);
    }
}

打印结果为：

Integer Array: 1 2 3 4 5 
Double Array: 1.1 2.2 3.3 4.4 5.5 
Character Array: H E L L O 

4. 思考——泛型的类可以被重载吗？

泛型类当然是可以被重载的。在重载泛型类时，可以使用相同的类名和不同的类型参数列表来创建新的泛型类。例如，下面是一个泛型类的重载示例：

public class Example<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

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

public class Example<U, V> {
    private U first;
    private V second;

    public Example(U first, V second) {
        this.first = first;
        this.second = second;
    }

    public U getFirst() {
        return first;
    }

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

    public V getSecond() {
        return second;
    }

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

在这个示例中，Example 泛型类被重载了，创建了一个新的泛型类 Example<U, V>。这个类有两个类型参数，分别为 U 和 V。与原来的 Example<T> 类不同，这个类有两个成员变量 first 和 second，并且提供了相应的 getter`和 setter 方法。