Java 泛型中的通配符详解

快来打我* 2024-03-30 10:27 85阅读 0赞

**目录**

1、如何定义和使用上界通配符？

2、如何定义和使用无界通配符？

3、如何定义和使用下界通配符？

4、如何使用通配符定义泛型类或接口之间的子类型关系？

5、通配符的捕获和辅助方法

6、通配符使用指南

--------------------

在泛型代码中，问号(?)称为通配符，用来表示未知类型。通配符可以在多种情况下使用：如作为参数、字段或局部变量的类型；有时也可以作为返回类型。另外，通配符永远不会用作调用泛型方法、创建泛型类或超类型实例的类型参数。

**为什么使用通配符？**

在 Java 中，类和数组之间的对象关系是可以继承的，比如 Dog extends Animal，那么 Animal\[\] 与 Dog\[\] 就是兼容的。但是集合之间却不存在这种关系，也就是说 List<Animal> 不是List<Dog> 的父类，他们之间没有任何关系。那么为了建立两个集合之间的联系，就需要用到通配符。// 只是其中一部分原因

#### 1、如何定义和使用上界通配符？ ####

可以使用上界通配符来放宽对变量的限制。例如，你想编写一个方法，该方法适用于List<Integer>， List<Double> 和 List<Number>；就可以通过使用上界通配符来实现这一点。

声明一个上界通配符，需要使用通配符 ('?')，跟上 extends 关键字，然后再跟它的上界。比如，编写用于 Number 列表和 Number 子类型（如 Integer、Double 和 Float）的方法，可以指定 List<? extends Number>。List<? extends Number> 要比 List<Number> 对类型的限制更加宽松，因为 List<Number> 只匹配类型为 Number 的列表，而 List<? extends Number> 匹配类型为 Number 或其任何子类的列表。

例如下边的程序代码：

public static void process(List<? extends Foo> list) { /* ... */ }

上界通配符 <? extends Foo> 中的 Foo 匹配 Foo 类型和 Foo 的任何子类型。process() 方法可以访问类型为 Foo 的列表元素：

public static void process(List<? extends Foo> list) {
        for (Foo elem : list) {
            // ...
        }
    }

在 foreach 子句中，elem 变量迭代列表中的每个元素。在 elem 元素上可以使用 Foo 类中定义的任何方法。

如下，sumOfList() 方法返回列表中数字的和：

public static double sumOfList(List<? extends Number> list) {
        double s = 0.0;
        for (Number n : list)
            s += n.doubleValue();
        return s;
    }

下面的代码，使用一个 Integer 对象列表，输出 sum = 6.0：

List<Integer> li = Arrays.asList(1, 2, 3);
    System.out.println("sum = " + sumOfList(li));

Double 值列表可以使用相同的 sumOfList() 方法。下面的代码输出 sum = 7.0：

List<Double> ld = Arrays.asList(1.2, 2.3, 3.5);
    System.out.println("sum = " + sumOfList(ld));

#### 2、如何定义和使用无界通配符？ ####

无界通配符类型使用通配符(?)指定，例如 List<?>。在下边两种情况下，无界通配符是一种有用的方法：

1.  编写一个方法，该方法可以使用 Object 类中提供的功能函数。
2.  代码在泛型类中使用不依赖于类型参数的方法。例如，List.size 或 List.clear。事实上，Class<?> 之所以如此常用，是因为 Class<T> 中的大多数方法都不依赖于 T。

例如以下 printList() 方法：

public static void printList(List<Object> list) {
        for (Object elem : list)
            System.out.println(elem + " ");
        System.out.println();
    }

printList() 的目标是用来打印任何类型的列表，但上述代码中它只能打印 Object 实例的列表；并不能打印 List<Integer>， List<String>， List<Double> 等，因为这些列表不是 List<Object> 的子类型。所以如果要编写一个通用的 printList() 方法，需要使用到 List<?>：

public static void printList(List<?> list) {
        for (Object elem: list)
            System.out.print(elem + " ");
        System.out.println();
    }

对于任何具体的类型 A，List<A> 都是 List<?> 的子类，可以使用 printList() 打印任何类型的列表：// 解决了之前 List<A> 和 List<B> 无任何关系的问题

List<Integer> li = Arrays.asList(1, 2, 3);
    List<String>  ls = Arrays.asList("one", "two", "three");
    printList(li);
    printList(ls);

注意：List<Object> 和 List<?> 是不一样的。可以将 Object 或 Object 的任何子类型插入到 List<Object> 中，但是只能将 null 插入到 List<?> 中。

#### 3、如何定义和使用下界通配符？ ####

上界通配符将未知类型限制为特定类型的子类型，使用 extends 关键字表示。类似地，下界通配符将未知类型限制为特定类型的超类型，使用 super 关键字表示。

下界通配符使用通配符('?')表示，后面跟着 super 关键字，然后再跟着它的下界：<? super A>。

注意：可以为通配符指定上界，也可以指定下界，但不能同时都指定。

例如，编写一个将 Integer 对象放入列表的方法。为了最大限度地提高灵活性，该方法需要适用于 List<Integer>、List<Number> 和 List<Object> 等任何可以保存 Integer 值的对象。那么要编写处理 Integer 列表和 Integer 超类型列表的方法，就可以使用 List<? super Integer> 来指定。如以下代码将数字 1 到 10 添加到列表的末尾：

public static void addNumbers(List<? super Integer> list) {
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
    }

#### 4、如何使用通配符定义泛型类或接口之间的子类型关系？ ####

泛型类或接口之间的关联并不取决于它们的类型之间是否存在关联。不过，我们可以使用通配符来创建泛型类或接口之间的关联关系。

给定以下两个非泛型类：

class A { /* ... */ }
    class B extends A { /* ... */ }

编写以下代码是合理的：

B b = new B();
    A a = b;

上边这个例子表明常规类的继承遵循子类型的规则：如果 B 继承 A，那么 B.calss 就是 A.calss 的子类型。但是这个规则并不适用于泛型类型：

List<B> lb = new ArrayList<>();
    List<A> la = lb;   // compile-time error

假设 Integer 是 Number 的子类型，那么 List<Integer> 和 List<Number> 之间的关系是什么呢?

![c561df7f3f3249ef864e60741e640fc6.png][]

虽然 Integer 是 Number 的子类型，但 List<Integer> 并不是 List<Number> 的子类型，所以，这两种类型并不相关。事实上，List<Number> 和 List<Integer> 的公共父类是 List<?>。

为了在这些类之间创建关系，让代码可以通过 List<Integer> 的元素访问 Number 的方法，可以使用一个上界通配符：

List<? extends Integer> intList = new ArrayList<>();
    List<? extends Number>  numList = intList;  // OK. List<? extends Integer> is a subtype of List<? extends Number>

因为 Integer 是 Number 的子类型，而 numList 是 Number 对象的列表，所以 intList (Integer对象的列表)和 numList 之间存在关联关系。下图显示了用上下界通配符声明的几个 List 类之间的关系。// 使用通配符可以定义两个类型之间的关系

![6ecb79fa1e64410b90a0c200b84f10b8.png][]

#### 5、通配符的捕获和辅助方法 ####

在某些情况下，编译器会自动推断通配符的类型。例如，列表可以定义为 List<?>，但是，当计算表达式时，编译器会从代码中推断出特定的类型，这种场景称为通配符捕获。

大多数情况下，都不需要担心通配符的捕获，除非看到包含短语 “capture of” 的错误消息。

如下，WildcardError 示例会在编译时会产生一个捕获错误：

import java.util.List;
    
    public class WildcardError {
    
        void foo(List<?> i) {
            i.set(0, i.get(0));
        }
    }

在本例中，编译器将 i 输入形参处理为 Object 类型。当 foo 方法调用 List.set(int, E) 时，编译器无法确认插入到列表中的对象类型，所以会产生错误。当发生这种类型的错误时，通常意味着编译器认为给变量分配了错误的类型。将泛型添加到 Java 语言中就是出于这个原因——在编译时加强类型安全。

当使用 Oracle 的 JDK 7 javac 实现编译时，WildcardError 示例会生成以下错误：

WildcardError.java:6: error: method set in interface List<E> cannot be applied to given types;
        i.set(0, i.get(0));
         ^
      required: int,CAP#1
      found: int,Object
      reason: actual argument Object cannot be converted to CAP#1 by method invocation conversion
      where E is a type-variable:
        E extends Object declared in interface List
      where CAP#1 is a fresh type-variable:
        CAP#1 extends Object from capture of ?
    1 error

在本例中，代码试图执行安全操作，那么如何解决编译器错误呢？可以通过编写一个捕获通配符的私有 helper 方法来修复它。如 WildcardFixed 所示，通过创建私有辅助方法 fooHelper 来解决这个问题：

public class WildcardFixed {
    
        void foo(List<?> i) {
            fooHelper(i);
        }
    
        // 创建辅助方法，以便可以通过类型推断捕获通配符
        private <T> void fooHelper(List<T> l) {
            l.set(0, l.get(0));
        }
    }

由于使用了 helper 方法，编译器使用推断来确定调用中的 T 是 CAP\#1，即捕获变量。示例现在编译成功。

#### 6、通配符使用指南 ####

在使用泛型进行编程时，让人比较困惑的是需要确定何时使用上界通配符，何时使用下界通配符。本节提供了一些设计代码时要遵循的指导原则。// 以下是来自官方的指导原则

为了方便理解，可以将变量看作以下两种形式：

*  **“in” 变量：**“in” 变量为代码提供数据。比如一个复制方法有两个参数：copy(src, dest)。src 参数提供了需要复制的数据，因此它是 “in” 形参。
 *  **“out” 变量：**“out” 变量用来保存输出数据，便于该数据在其他地方使用。在 copy(src, dest) 方法中， dest 参数用来接收数据，因此它是 "out" 形参。

当然，有些变量同时用于 “输入” 和 “输出” 目的，下边指南中也提到了这种情况。

在决定是否使用通配符以及使用什么类型的通配符时，可以使用 “in” 和 “out” 原则。以下列表提供了需要遵循的指导方针：

1.  对于 “in” 变量，可以定义一个上界通配符，使用 extends 关键字。
2.  对于“out”变量，可以定义一个下界通配符，使用 super 关键字。
3.  如果 “in” 变量可以使用 Object.calss 中定义的方法对其进行访问，可以使用无界通配符。
4.  如果变量同时用于 “输入” 和 “输出”的情况下，不要使用通配符。// 限定唯一的类型

以上这些准则不适用于方法的返回类型。应该避免使用通配符作为方法的返回类型，因为它会迫使使用代码的程序员去处理通配符。

List<? extends ...> 可以认为它是只读的，但并不能进行严格的保证，假设有以下两个类：

class NaturalNumber {
    
        private int i;
    
        public NaturalNumber(int i) { this.i = i; }
        // ...
    }
    
    class EvenNumber extends NaturalNumber {
    
        public EvenNumber(int i) { super(i); }
        // ...
    }

考虑下面的代码：

List<EvenNumber> le = new ArrayList<>();
    List<? extends NaturalNumber> ln = le;
    ln.add(new NaturalNumber(35));  // 编译错误

因为 List<EvenNumber> 是 List<? extends NaturalNumber> 的子类型，所以可以将 le 赋值给 ln。但是却不能用 ln 把一个自然数加到一个偶数列表中。在该列表中只可以进行以下操作:

1.  添加 null 元素。
2.  调用 clear() 方法。
3.  获取迭代器并调用 remove() 方法。
4.  捕获通配符并写入从列表中读取的元素。

所以，从严格意义上来讲，List<? extends NaturalNumber> 并不是只读的，但是却可以认为它是只读的，因为不能在列表中存储新的元素或更改现有元素。

[c561df7f3f3249ef864e60741e640fc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6999178d09114c758ca859ca5e65d091.png
[6ecb79fa1e64410b90a0c200b84f10b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/207a0add496d47ca92ba6ecaa991fe62.png