Java泛型中的通配符举例详解

前言

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

为什么使用通配符？

在 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> 之间的关系是什么呢?

虽然 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 类之间的关系。// 使用通配符可以定义两个类型之间的关系

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、通配符使用指南

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

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

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

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

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

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

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

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 把一个自然数加到一个偶数列表中。在该列表中只可以进行以下操作:

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

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

总结

到此这篇关于Java泛型中的通配符的文章就介绍到这了,更多相关Java泛型的通配符内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论