Java基础- 泛型

泛型是 Java 编程语言的一个特性，它允许在编写和使用类、接口和方法时添加类型参数。泛型的主要目的是提高代码的可重用性、类型安全性和可读性。

泛型方法允许在方法级别上指定类型参数，提供了极大的灵活性和类型安全性。以下是一个泛型方法的示例，该方法可以交换数组中的两个元素的位置：

public class GenericMethods {

    // 泛型方法：交换数组中的两个元素
    public static <T> void swap(T[] array, int firstIndex, int secondIndex) {
        T temp = array[firstIndex];
        array[firstIndex] = array[secondIndex];
        array[secondIndex] = temp;
    }

    public static void main(String[] args) {
        // Integer 数组
        Integer[] intArray = {1, 2, 3, 4};
        System.out.println("原始 Integer 数组: " + Arrays.toString(intArray));
        swap(intArray, 0, 2);
        System.out.println("交换后的 Integer 数组: " + Arrays.toString(intArray));

        // String 数组
        String[] stringArray = {"Hello", "World", "Java", "Generics"};
        System.out.println("\n原始 String 数组: " + Arrays.toString(stringArray));
        swap(stringArray, 1, 3);
        System.out.println("交换后的 String 数组: " + Arrays.toString(stringArray));
    }
}

在上述例子中：

• swap 方法是一个泛型方法，其类型参数是 <T>。这意味着这个方法可以接受任何类型的数组。
• 方法的签名 public static <T> void swap(T[] array, int firstIndex, int secondIndex) 显示了泛型类型 <T>，表示数组中的元素类型。
• 在 main 方法中，我们分别对一个 Integer 数组和一个 String 数组使用了 swap 方法，展示了其在不同类型上的通用性。

泛型方法的优点在于，我们可以编写一个方法，它可以在不同类型的数据上工作，而不需要针对每种数据类型编写重复的代码。这增加了代码的重用性和灵活性，同时提高了类型安全性。

在泛型方法 public static <T> void swap(T[] array, int firstIndex, int secondIndex) 中，第一个 <T> 是用来声明类型参数 T 的。这个声明告诉编译器，T 是一个类型参数，它将在整个方法中代表某个类型。这个类型将在方法调用时确定，基于传递给方法的参数。

1. 类型参数的声明：

   • <T> 是泛型方法的一部分，它在方法的返回类型之前出现，用于声明一个或多个类型参数。
   • 这里，T 是一个类型占位符，代表一个未知的类型。

2. 方法签名中的使用：

   • 在方法的参数列表中使用了 T（例如 T[] array），这意味着这个方法可以接受任何类型的数组。

3. 类型参数的作用：

   • 这种声明方式使得 swap 方法可以接受任何类型的数组，例如 Integer[]、String[] 或任何其他对象类型数组。
   • 在方法被调用时，例如 swap(intArray, 0, 2)，编译器会根据传入的数组类型（在这个例子中是 Integer[]）来推断 T 的具体类型。

4. 泛型的优点：

   • 这种泛型方法的写法提高了代码的重用性和灵活性。相同的方法可以用于不同类型的数据，而无需针对每种数据类型重写方法。

5. 区别于类级别的泛型：

   • 在泛型类中，类型参数通常在类名之后声明（如 class MyClass<T>）。但在泛型方法中，类型参数在方法返回类型之前声明，即使该方法是在泛型类中定义的。

总之，方法中的 <T> 是泛型方法的关键部分，它使得方法能够灵活地处理不同类型的数据，同时保持类型安全和清晰的代码结构。

如果一个泛型方法包含多个泛型类型参数，这些类型参数会在方法的声明中一起被指定。这允许方法在不同类型的参数上操作，而这些类型彼此之间可以是完全独立的。下面是一个包含多个泛型类型参数的方法的例子：

public class GenericMethodExample {

    // 一个包含两个泛型类型参数的方法
    public static <T, U> void printArray(T[] arrayT, U[] arrayU) {
        for (T element : arrayT) {
            System.out.print(element + " ");
        }
        System.out.println();

        for (U element : arrayU) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4};
        String[] stringArray = {"Hello", "World"};

        // 调用具有两个不同泛型类型的方法
        printArray(intArray, stringArray);
    }
}

在这个例子中：

1. printArray 方法有两个泛型类型参数：<T, U>。

   • 这意味着这个方法可以接受两种不同类型的数组。
   • T[] arrayT 和 U[] arrayU 分别是这两种类型的数组。

2. 在 main 方法中，我们传递了一个 Integer 类型的数组和一个 String 类型的数组给 printArray 方法。

   • T 在这个调用中被推断为 Integer。
   • U 被推断为 String。

这个方法展示了如何使用多个泛型类型参数来提供更大的灵活性。通过这种方式，可以编写能够处理多种不同类型数据的通用代码，从而增强代码的重用性和可维护性。