日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

引言

泛型是Java中一個非常重要的知識點，在Java集合類框架中泛型被廣泛應(yīng)用。本文我們將從零開始來看一下Java泛型的設(shè)計，將會涉及到通配符處理，以及讓人苦惱的類型擦除。

創(chuàng)新互聯(lián)長期為上1000家客戶提供的網(wǎng)站建設(shè)服務(wù)，團隊從業(yè)經(jīng)驗10年，關(guān)注不同地域、不同群體，并針對不同對象提供差異化的產(chǎn)品和服務(wù)；打造開放共贏平臺，與合作伙伴共同營造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為江岸企業(yè)提供專業(yè)的網(wǎng)站設(shè)計、成都網(wǎng)站建設(shè)，江岸網(wǎng)站改版等技術(shù)服務(wù)。擁有10多年豐富建站經(jīng)驗和眾多成功案例,為您定制開發(fā)。

[[184604]]

泛型基礎(chǔ)

泛型類

我們首先定義一個簡單的Box類：

public class Box {
    private String object;
    public void set(String object) { this.object = object; }
    public String get() { return object; }
}

這是最常見的做法，這樣做的一個壞處是Box里面現(xiàn)在只能裝入String類型的元素，今后如果我們需要裝入Integer等其他類型的元素，還必須要另外重寫一個Box，代碼得不到復(fù)用，使用泛型可以很好的解決這個問題。

public class Box {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

這樣我們的Box類便可以得到復(fù)用，我們可以將T替換成任何我們想要的類型：

Box integerBox = new Box();
Box doubleBox = new Box();
Box stringBox = new Box();

泛型方法

看完了泛型類，接下來我們來了解一下泛型方法。聲明一個泛型方法很簡單，只要在返回類型前面加上一個類似的形式就行了：

public class Util {
    public static  boolean compare(Pair p1, Pair p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}
public class Pair {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
    public K getKey()   { return key; }
    public V getValue() { return value; }
}

我們可以像下面這樣去調(diào)用泛型方法：

Pair p1 = new Pair<>(1, "apple");
Pair p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

或者在Java1.7/1.8利用type inference，讓Java自動推導(dǎo)出相應(yīng)的類型參數(shù)：

Pair p1 = new Pair<>(1, "apple");
Pair p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

邊界符

現(xiàn)在我們要實現(xiàn)這樣一個功能，查找一個泛型數(shù)組中大于某個特定元素的個數(shù)，我們可以這樣實現(xiàn)：

public static  int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e > elem)  // compiler error
            ++count;
    return count;
}

但是這樣很明顯是錯誤的，因為除了short, int, double, long, float, byte, char等原始類型，其他的類并不一定能使用操作符>，所以編譯器報錯，那怎么解決這個問題呢？答案是使用邊界符。

public interface Comparable {
    public int compareTo(T o);
}

做一個類似于下面這樣的聲明，這樣就等于告訴編譯器類型參數(shù)T代表的都是實現(xiàn)了Comparable接口的類，這樣等于告訴編譯器它們都至少實現(xiàn)了compareTo方法。

public static > int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e.compareTo(elem) > 0)
            ++count;
    return count;
}

通配符

在了解通配符之前，我們首先必須要澄清一個概念，還是借用我們上面定義的Box類，假設(shè)我們添加一個這樣的方法：

public void boxTest(Box n) { /* ... */ }

那么現(xiàn)在Box n允許接受什么類型的參數(shù)？我們是否能夠傳入Box或者Box呢？答案是否定的，雖然Integer和Double是Number的子類，但是在泛型中Box或者Box與Box之間并沒有任何的關(guān)系。這一點非常重要，接下來我們通過一個完整的例子來加深一下理解。

首先我們先定義幾個簡單的類，下面我們將用到它：

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}

下面這個例子中，我們創(chuàng)建了一個泛型類Reader，然后在f1()中當(dāng)我們嘗試Fruit f = fruitReader.readExact(apples);編譯器會報錯，因為List與List之間并沒有任何的關(guān)系。

public class GenericReading {
    static List apples = Arrays.asList(new Apple());
    static List fruit = Arrays.asList(new Fruit());
    static class Reader {
        T readExact(List list) {
            return list.get(0);
        }
    }
    static void f1() {
        Reader fruitReader = new Reader();
        // Errors: List cannot be applied to List.
        // Fruit f = fruitReader.readExact(apples);
    }
    public static void main(String[] args) {
        f1();
    }
}

但是按照我們通常的思維習(xí)慣，Apple和Fruit之間肯定是存在聯(lián)系，然而編譯器卻無法識別，那怎么在泛型代碼中解決這個問題呢？我們可以通過使用通配符來解決這個問題：

static class CovariantReader {
    T readCovariant(List list) {
        return list.get(0);
    }
}
static void f2() {
    CovariantReader fruitReader = new CovariantReader();
    Fruit f = fruitReader.readCovariant(fruit);
    Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
    f2();
}

這樣就相當(dāng)與告訴編譯器， fruitReader的readCovariant方法接受的參數(shù)只要是滿足Fruit的子類就行(包括Fruit自身)，這樣子類和父類之間的關(guān)系也就關(guān)聯(lián)上了。

PECS原則

上面我們看到了類似的用法，利用它我們可以從list里面get元素，那么我們可不可以往list里面add元素呢？我們來嘗試一下：

public class GenericsAndCovariance {
    public static void main(String[] args) {
        // Wildcards allow covariance:
        List flist = new ArrayList();
        // Compile Error: can't add any type of object:
        // flist.add(new Apple())
        // flist.add(new Orange())
        // flist.add(new Fruit())
        // flist.add(new Object())
        flist.add(null); // Legal but uninteresting
        // We Know that it returns at least Fruit:
        Fruit f = flist.get(0);
    }
}

答案是否定，Java編譯器不允許我們這樣做，為什么呢？對于這個問題我們不妨從編譯器的角度去考慮。因為List flist它自身可以有多種含義：

List flist = new ArrayList();
List flist = new ArrayList();
List flist = new ArrayList();

• 當(dāng)我們嘗試add一個Apple的時候，flist可能指向new ArrayList();
• 當(dāng)我們嘗試add一個Orange的時候，flist可能指向new ArrayList();
• 當(dāng)我們嘗試add一個Fruit的時候，這個Fruit可以是任何類型的Fruit，而flist可能只想某種特定類型的Fruit，編譯器無法識別所以會報錯。

所以對于實現(xiàn)了的集合類只能將它視為Producer向外提供(get)元素，而不能作為Consumer來對外獲取(add)元素。

如果我們要add元素應(yīng)該怎么做呢？可以使用：

public class GenericWriting {
    static List apples = new ArrayList();
    static List fruit = new ArrayList();
    static  void writeExact(List list, T item) {
        list.add(item);
    }
    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruit, new Apple());
    }
    static  void writeWithWildcard(List list, T item) {
        list.add(item)
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }
    public static void main(String[] args) {
        f1(); f2();
    }
}

這樣我們可以往容器里面添加元素了，但是使用super的壞處是以后不能get容器里面的元素了，原因很簡單，我們繼續(xù)從編譯器的角度考慮這個問題，對于List list，它可以有下面幾種含義：

List list = new ArrayList();
List list = new ArrayList();
List list = new ArrayList