java泛型

假设有一个类层次结构如下：

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

通配符的超类型（上限）限定

语法<? extends T>，

含义：表示类型是 T 或其子类型。
特点：

• 只能从中读取数据，且读取的数据类型是 T。

• 不能向其中写入数据（除了 null），因为具体类型未知。

你需要一个方法，能够处理 Animal 及其子类型的列表，并读取其中的数据：

public void printAnimals(List<? extends Animal> animals) {
    for (Animal animal : animals) {
        System.out.println(animal);
    }
}

List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());

List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());

printAnimals(dogs); // 可以处理 Dog 列表
printAnimals(cats); // 可以处理 Cat 列表

为什么用 <? extends T>：

• 方法可以接受 Animal 及其子类型的列表（如 List<Dog> 或 List<Cat>）。

• 从列表中读取的数据可以安全地视为 Animal 类型。

不允许写入元素

// Cat 是 Animal子类
List<? extends Animal> pets = new ArrayList<>();
pets.add(new Cat()); // 编译错误
pets.add(new Dog()); // 编译错误
pets.add(new Animal()); // 编译错误
pets.add(null); // 允许，因为 null 是所有引用类型的有效值

原因在于 List<? extends Animal> 使用了 通配符的超类型限定（Upper Bounded Wildcard），这种限定方式在泛型中限制了集合的写入操作。List<? extends Animal> 表示这是一个可以存储 Animal 或其子类型（如 Cat、Dog）的列表，但具体是哪种子类型是未知的。编译器无法确定 pets 的实际类型是 List<Cat>、List<Dog> 还是 List<Animal>，因此为了保证类型安全，编译器会禁止向这种列表中添加任何非 null 的元素。

具体原因：

1. 类型不确定性：

   • List<? extends Animal> 可能是 List<Cat>、List<Dog> 或 List<Animal>。

   • 如果你尝试添加一个 Cat，而 pets 实际上是 List<Dog>，就会导致类型不匹配，破坏类型安全。

2. 编译器的保护机制：

   • 为了避免运行时出现 ClassCastException，编译器直接禁止向 List<? extends Animal> 中添加任何元素（除了 null）。

如果你需要向列表中添加元素，应该使用 确定的具体类型 或者 通配符的下限限定（Lower Bounded Wildcard）。

1. 使用具体类型：

如果你知道列表的具体类型是 Cat，可以直接使用 List<Cat>：

List<Cat> cats = new ArrayList<>();
cats.add(new Cat()); // 允许

2. 使用下限限定（<? super T>）：

如果你希望列表可以接受 Animal 及其父类型（如 Object），可以使用 List<? super Cat>：

List<? super Cat> pets = new ArrayList<>();
pets.add(new Cat()); // 允许，因为 Cat 是 Animal 的子类型
pets.add(new Animal()); // 编译错误，因为 Animal 是 Cat 的父类型

通配符的子类型（下限）限定

语法<? super T>

含义：表示类型是 T 或其父类型。
特点：

• 可以向其中写入 T 类型的数据。

• 只能从中读取 Object 类型的数据，因为具体类型未知。

使用场景：
当你需要向一个集合中写入数据，并且希望代码能够处理 T 及其父类型的集合时。

public void addDog(List<? super Dog> dogs) {
    dogs.add(new Dog()); // 可以安全地添加 Dog 对象
}

List<Animal> animals = new ArrayList<>();
List<Dog> dogs = new ArrayList<>();
List<Object> objects = new ArrayList<>();

addDog(animals); // 可以处理 Animal 列表
addDog(dogs);    // 可以处理 Dog 列表
addDog(objects); // 可以处理 Object 列表

为什么用 <? super T>：

• 方法可以接受 Dog 及其父类型的列表（如 List<Animal> 或 List<Object>）。

• 可以向列表中添加 Dog 类型的对象。

虽然允许写入元素，但不允许写入T的父类元素

public void addDog(List<? super Dog> dogs) {
    dogs.add(new Dog()); // 安全，因为 Dog 是 ? super Dog 的子类型
    dogs.add(new Animal()); // 编译错误，因为 Animal 是 Dog 的父类型
}

在Java泛型中，List<? super Dog> 表示一个可以接受 Dog 类型或其任何父类型的列表。虽然这种通配符限定允许你向列表中添加 Dog 类型的对象，但它并不允许添加 Dog 的父类型对象（例如 Animal）。这就是为什么在 dogs.add(new Animal()); 这行代码会报错。

原因分析

1. 类型安全性：

   • List<? super Dog> 表示列表的元素类型是 Dog 或其父类型（例如 Animal 或 Object）。

   • 你可以向这样的列表中添加 Dog 类型的对象，因为 Dog 是 ? super Dog 的子类型，符合类型安全。

   • 但是，你不能添加 Animal 类型的对象，因为 Animal 是 Dog 的父类型，而 ? super Dog 并不保证列表的具体类型是 Animal。列表的实际类型可能是 Dog 或 Object，因此添加 Animal 可能会导致类型不安全。

2. 编译器限制：

   • 编译器无法确定 List<? super Dog> 的具体类型是什么。它只知道这个列表可以接受 Dog 或其父类型的对象。

   • 由于 Animal 是 Dog 的父类型，编译器无法保证 Animal 类型的对象可以安全地添加到列表中。因此，编译器会报错以避免潜在的类型安全问题。

对比超类型限定和子类型限定

<T extends Comparable<? super T>> 和 <T extends Comparable>比较

在大多数情况下，推荐使用 <T extends Comparable<? super T>>，因为它提供了更大的灵活性和类型安全性。

• <T extends Comparable<? super T>>：更灵活，允许 T 与其父类进行比较。

• <T extends Comparable>：限制更严格，要求 T 直接实现 Comparable。

相同点

1. 类型约束：两者都要求 T 实现 Comparable 接口。

2. 泛型使用：都用于限制泛型类型参数 T 的范围。

不同点

1. 灵活性：

   • <T extends Comparable<? super T>>：允许 T 实现 Comparable 接口，且 Comparable 的类型参数可以是 T 或其父类。这意味着 T 可以与自身或其父类进行比较，提供了更大的灵活性。

   • <T extends Comparable>：要求 T 直接实现 Comparable 接口，且类型参数必须是 T 自身，限制更严格。

2. 类型安全性：

   • <T extends Comparable<? super T>>：更灵活且类型安全，允许 T 与其父类进行比较，减少了类型转换的需要。

   • <T extends Comparable>：类型安全性较低，可能需要进行类型转换，增加了运行时错误的风险。

例如以下场景，假设两个类

class Animal implements Comparable<Animal> {
    public int compareTo(Animal other) {
        // 实现比较逻辑
        return 0;
    }
}

class Dog extends Animal {
    // Dog 继承了 Animal 的 compareTo 方法
}

• 对于<T extends Comparable<? super T>>：

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    // 可以接受 List<Animal> 或 List<Dog>
}

这里 T 可以是 Animal 或 Dog，因为 Dog 继承了 Animal 的 compareTo 方法。

• 对于<T extends Comparable>：

public static <T extends Comparable> void sort(List<T> list) {
    // 只能接受 List<Animal>，不能接受 List<Dog>
}

这里 T 必须是直接实现 Comparable 的类型，如 Animal，而不能是 Dog，因为 Dog 没有直接实现 Comparable。

无界通配符

通配符捕获（Wildcard Capture）

Java 泛型中的一个概念，用于处理泛型类型中通配符（?）的具体类型推断问题。通配符本身表示未知类型，但在某些情况下，编译器需要推断出通配符的具体类型以便进行类型安全的操作。这种推断过程称为“通配符捕获”。

• 背景

通配符类型（如 List<?>）本身是只读的，不能直接修改。如果需要修改通配符类型的对象，必须通过通配符捕获来推断出具体类型，从而保证类型安全。

• 示例

public void swap(List<?> list, int i, int j) {
    // 通配符捕获：编译器推断出通配符的具体类型
    swapHelper(list, i, j);
}

// 辅助方法：用于捕获通配符的具体类型
private <T> void swapHelper(List<T> list, int i, int j) {
    T temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
}

解释：

1. swap 方法：

   • 参数 List<?> 是一个通配符类型，表示未知类型的列表。

   • 由于 List<?> 不能直接修改（只能读取为 Object），我们需要一个辅助方法来处理具体类型。

2. swapHelper 方法：

   • 这是一个泛型方法，类型参数 T 被用来捕获 List<?> 中的具体类型。

   • 编译器会推断出 T 是 List<?> 中实际的元素类型，从而允许安全地操作列表。

3. 通配符捕获：

   • 在调用 swapHelper 时，编译器会“捕获” List<?> 中的具体类型，并将其作为 T 传递给 swapHelper。

   • 这样，swapHelper 就可以安全地操作列表元素。

List 和 List<?>的区别

1. List（原始类型，Raw Type）

• 定义：List 是一个没有指定类型参数的泛型类，称为原始类型（Raw Type）。

• 特点：

  • 可以存储任意类型的对象（类似于 List<Object>）。

  • 失去了泛型的类型检查，编译器不会对元素的类型进行约束。

  • 使用时需要手动进行类型转换，容易引发运行时异常（如 ClassCastException）。

• 如下，类型不安全，容易引发运行时错误

  List list = new ArrayList();
  list.add("Hello");
  list.add(123); // 可以存储任意类型
  String str = (String) list.get(0); // 需要强制类型转换
  Integer num = (Integer) list.get(1); // 需要强制类型转换

2. List<?>（无界通配符类型，Unbounded Wildcard）

• 定义：List<?> 表示一个未知类型的泛型列表，称为无界通配符类型。

• 特点：

  • 可以接受任何类型的 List，例如 List<String>、List<Integer> 等。

  • 不能向其中添加任何元素（除了 null），因为类型未知。

  • 只能从中读取元素，且读取的元素类型是 Object。

• 如下， 通常用于编写通用方法，可以接受任意类型的 List

List<?> list = new ArrayList<String>();
list.add(null); // 只能添加 null
Object obj = list.get(0); // 读取的元素类型是 Object