泛型之extends通配符

泛型的繼承關系：Pair<Integer>不是Pair<Number>的子類。

extends通配符

import java.util.*;
public class Demo13{

    public static void main(String[] args) throws Exception{
        //實例化一個Pair<Integer>泛型類
        Pair<Integer> p = new Pair<>(12,34);
        int n = add(p);
        System.out.println(n);        
    }
    
    //此靜態方法形參是傳入一個Pair<Number>的泛型實例
    static int add(Pair<Number> p){
        Number first = p.getFirst();
        Number last = p.getLast();
        //Number類型使用intValue()返回int類型
        return first.intValue() + last.intValue();
    }
}

//定義一個泛型類
class Pair<T> {
    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;
    }    
}

 

原因很明顯，因為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類型。我們把代碼局部改寫如下：

    //此靜態方法形參是傳入一個Pair<Number>的泛型實例
    //static int add(Pair<Number> p){
        
    //形參改為傳入一個Pair<? extends Number>的泛型實例,
    //Pair<? extends Number>使得方法接收所有泛型類型為Number或Number子類的Pair類型
    static int add(Pair<? extends Number> p){
        Number first = p.getFirst();
        Number last = p.getLast();
        //Number類型使用intValue()返回int類型
        return first.intValue() + last.intValue();
    }

這樣一來，給方法傳入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()方法，實際的方法簽名變成了：

<? extends Number> getFirst();

即返回值是Number或Number的子類，因此，可以安全賦值給Number類型的變量：

Number x = p.getFirst();

 然后，我們不可預測實際類型就是Integer，例如，下面的代碼是無法通過編譯的：

Integer x = p.getFirst();

這是因為實際的返回類型可能是Integer，也可能是Double或者其他類型，編譯器只能確定類型一定是Number的子類（包括Number類型本身），但具體類型無法確定。

 

我們再來考察一下Pair<T>的set方法：

package day1_8;

public class Extends_Super {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(12,34);
        System.out.println(add(p));
    }
    static int add(Pair<? extends Number> p){
        Number first = p.getFirst();
        Number last = p.getLast();
        p.setFirst(new Integer(first.intValue()+100));
        p.setLast(new Integer(last.intValue() + 100));
        return  p.getFirst().intValue() + p.getLast().intValue();
    }
}

class Pair<T> {
    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;
    }
}

不出意外，我們會得到一個編譯錯誤：

 

 

 

編譯錯誤發生在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<T> {
    int size(); // 獲取個數
    T get(int index); // 根據索引獲取指定元素
    void add(T t); // 添加一個新元素
    void remove(T t); // 刪除一個已有元素
}

現在，讓我們定義一個方法來處理列表的每個元素：

package day1_8;

import java.util.ArrayList;
import java.util.List;

public class Extends_Super {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println(sumOfList(list));
    }
　　//注意形參處是List<Integer>
    static int sumOfList(List<Integer> list){
        int sum = 0;
        for (int i = 0; i < 101; i++) {
            list.add(i);  //可以對list寫
            sum += list.get(i); //可以對list讀
        }
        return sum;
    }
}

 

 

 

 

  運行完全OK

 

接下來我們改動一處再看看

package day1_8;
import java.util.ArrayList;
import java.util.List;

public class Extends_Super {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println(sumOfList(list));
    }

    //注意形參改為<? extends Integer>通配符
    static int sumOfList(List<? extends Integer> list){
        int sum = 0;
        for (int i = 0; i < 101; i++) {
            //下面兩行是一樣的，因為Integer和int是自動拆裝和包裝的
            //list.add(i);  //不能對list寫
            list.add(new Integer(i)); //不能對list寫
            sum += list.get(i); //可以對list讀
        }
        return sum;
    }
}

 

 

 

 

 

為什么我們定義的方法參數類型是List<? extends Integer>而不是List<Integer>？從方法內部代碼看，傳入List<? extends Integer>或者List<Integer>是完全一樣的，但是，注意到List<? extends Integer>的限制：

• 允許調用get()方法獲取Integer的引用；
• 不允許調用set(? extends Integer)方法並傳入任何Integer的引用（null除外）。

因此，方法參數類型List<? extends Integer>表明了該方法內部只會讀取List的元素，不會修改List的元素（因為無法調用add(? extends Integer)、remove(? extends Integer)這些方法。換句話說，這是一個對參數List<? extends Integer>進行只讀的方法（惡意調用set(null)除外）。

使用extends限定T類型

在定義泛型類型Pair<T>的時候，也可以使用extends通配符來限定T的類型：

public class Pair<T extends Number> { ... }

現在，我們只能定義： 

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

因為Number、Integer和Double都符合<T extends Number>。

非Number類型將無法通過編譯：

Pair<String> p1 = null; // compile error!
Pair<Object> p2 = null; // compile error!

因為String、Object都不符合<T extends Number>，因為它們不是Number類型或Number的子類。

 

小結

使用類似<? extends Number>通配符作為方法參數時表示：

• 方法內部可以調用獲取Number引用的方法，例如：Number n = obj.getFirst();；

• 方法內部無法調用傳入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句話總結：使用extends通配符表示可以讀，不能寫。

使用類似<T extends Number>定義泛型類時表示：

• 泛型類型限定為Number以及Number的子類。

 

這里唯一的例外是可以給方法參數傳入null：