extends通配符转载

我们已经讨论过泛型继承关系： Pair<Integer> 不是 Pair<Number> 的子类。

假设我们定义 Pair<T> ：

public class Pair { ... }

然后，我们瞄准 Pair<Number> Type编写接收参数类型的静态方法。 Pair<Number> ：

public class PairHelper {
    static int add(Pair p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

上述代码可以正常编译。使用时，我们传入：

int sum = PairHelper.add(new Pair(1, 2));

注意：传入的类型为 Pair<Number> ，实际参数类型为 (Integer, Integer) 。

由于实际参数是 Integer 类型，请尝试传入 Pair<Integer> ：

public class Main {

}

class Pair { private T first; private T last; public Pair(T first, T last) { this.first = first; this.last = last; } public T getFirst() { return first; } public T getLast() { return last; } }

Run

直接运行时会出现编译错误：

incompatible types: Pair cannot be converted to Pair

原因是显而易见的，因为 Pair<Integer> 不是 Pair<Number> 因此， add(Pair<Number>) 不接受参数类型 Pair<Integer> 。

但是从 add() 该方法的代码知道传入的 Pair<Integer> 是完全符合内部代码的类型规范，因为语句：

Number first = p.getFirst();
Number last = p.getLast();

实际类型为 Integer ，引用类型为 Number ，没问题。问题是方法参数类型是固定的，只能传入。 Pair<Number> 。

没有办法让方法参数接受。 Pair<Integer> ？有一种方法，这就是使用。 Pair<? extends Number> 使该方法接收所有泛型类型 Number 或 Number 子类的 Pair 类型。我们按如下方式重写代码：

public class Main {

}

class Pair { private T first; private T last; public Pair(T first, T last) { this.first = first; this.last = last; } public T getFirst() { return first; } public T getLast() { return last; } }

Run

通过这种方式，该方法被传入。 Pair<Integer> 类型，则它符合参数。 Pair<? extends Number> 类型。此用途 <? extends Number> 的一般定义称为上界通配符(Upper Bounds Wildcards)，即泛型类型。 T 的上界 Number 了。

除了能够通过 Pair<Integer> 类型，我们也可以传入 Pair<Double> 类型， Pair<BigDecimal> 类型等，因为 Double 和 BigDecimal 都是 Number 的子类。

如果我们检查一下对 Pair<? extends Number> 类型调用 getFirst() 方法，则实际的方法签名将变为：

 getFirst();

也就是说，返回值为 Number 或 Number 因此，可以安全赋值给 Number 类型的变量：

Number x = p.getFirst();

那么，我们就无法预测实际的类型是 Integer 例如，无法编译以下代码：

Integer x = p.getFirst();

这是因为实际返回类型可能是 Integer ，也可能是 Double 或其他类型，则编译器只能确定该类型必须是 Number 子类(包括 Number 类型本身)，但无法确定具体类型。

让我们再看一遍。 Pair<T> 的 set 方法：

public class Main {

}

class Pair { private T first; private T last;

public Pair(T first, T last) {
    this.first = first;
    this.last = last;
}

public T getFirst() {
    return first;
}
public T getLast() {
    return last;
}
public void setFirst(T first) {
    this.first = first;
}
public void setLast(T last) {
    this.last = last;
}

}

Run

毫不奇怪，我们得到一个编译错误：

incompatible types: Integer cannot be converted to CAP#1
where CAP#1 is a fresh type-variable:
    CAP#1 extends Number from capture of ? extends Number

编译错误发生在 p.setFirst() 传入的参数包括 Integer 类型。有些童鞋会问，因为 p 的定义是 Pair<? extends Number> ，那么 setFirst(? extends Number) 为什么我不能进去？ Integer ？

原因也是擦拭的方法。如果我们进去了 p 是 Pair<Double> ，显然它满足参数定义。 Pair<? extends Number> ，然而， Pair<Double> 的 setFirst() 显然是不可接受的 Integer 类型。

这就是 <? extends Number> 通配符的一个重要限制是：方法参数签名。 setFirst(? extends Number) 没有交付任何 Number 类型给 setFirst(? extends Number) 。

这里唯一的例外是您可以传入方法参数。 null ：

p.setFirst(null); // ok, 但它将在稍后被抛出。NullPointerException
p.getFirst().intValue(); // NullPointerException

extends通配符的作用

如果我们检查Java标准库的 java.util.List<T> 接口，该接口实现类似于“变量数组”的列表，其主要功能包括：

public interface List {
    int size(); // 获取个数
    T get(int index); // 根据索引获取指定的元素。
    void add(T t); // 添加新元素
    void remove(T t); // 删除现有元素
}

现在，让我们定义一个方法来处理列表的每个元素：

int sumOfList(List list) {
    int sum = 0;
    for (int i=0; i

public class Pair { ... }

Pair p1 = null;
Pair p2 = new Pair<>(1, 2);
Pair p3 = null;

Pair p1 = null; // compile error!
Pair