Java泛型

Java泛型是Java语言的一个重要特性，它允许你在编译时指定类型参数，从而编写更加灵活和可重用的代码。

Java泛型的概念

Java泛型是在JDK 5.0中引入的，它允许你在声明类、接口和方法时使用类型参数。类型参数可以是你定义的任何标识符，通常使用大写字母如 E, T, K, V等表示。使用泛型的好处包括：

1. 类型安全：编译器会在编译期检查类型安全问题，避免了运行时可能出现的ClassCastException。
2. 代码复用性：通过泛型，你可以编写一次性的代码来处理多种不同的数据类型。
3. 清晰的类型信息：使用泛型可以让代码更具可读性，因为类型信息更加明显。

泛型的基本使用

类型参数

类型参数在声明时使用尖括号<>表示。例如，定义一个泛型类：

public class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}

这里的T是一个类型参数，代表“类型”。

创建泛型类的对象

创建泛型类的对象时，你需要指定具体的类型：

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");
String item = stringBox.getItem(); // 编译器检查类型安全

泛型方法

你也可以在方法级别使用泛型：

public class Utility {
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

调用该方法时同样需要指定类型：

Integer[] numbers = {1, 2, 3};
Utility.swap(numbers, 0, 2); // 编译器检查类型安全

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 <E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

实例

如下实例演示了我们如何定义一个泛型类:

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

泛型接口

接口也可以声明为泛型接口：

public interface List<T> {
    void add(T element);
    T get(int index);
    int size();
}

泛型的限制

1. 原始类型：在某些情况下，你可能需要使用未指定类型的泛型类，这称为原始类型。例如，List而不是List<String>。原始类型失去了泛型带来的好处。
2. 通配符：为了增加灵活性，Java允许使用通配符?来代替具体的类型参数。例如：

 List<?> list; // 可以接受任何类型的List

3. 类型限定：可以使用extends关键字来限定类型参数必须继承自某个类或实现某个接口：

 public class SomeList<T extends Comparable<T>> {
       // ...
   }

4. 类型通配符的上限和下限：还可以使用通配符加上extends或super关键字来指定类型参数的上限或下限：

  public void method(List<? extends Number> list) { // 只能接受Number及其子类
       // ...
   }

   public void method(List<? super Integer> list) { // 可以接受Integer或其父类
       // ...
   }

示例下面是一个简单的例子，演示了如何使用泛型类和方法：

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello World");
        String content = stringBox.getItem();
        System.out.println(content);

        swap(new Integer[]{1, 2}, 0, 1); // 交换数组中的两个元素
    }

    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}

这个例子中定义了一个泛型类Box和一个泛型方法swap。在主方法中，我们创建了一个Box<String>实例，并调用了swap方法来交换整数数组中的元素。