從零開始來看一下Java泛型的設計

引言

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

泛型基礎

泛型類

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

public?class?Box {

????private?String object;

????public?void?set(String object) { this.object = object; }

????public?String get() { return?object; }

}

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

public?class?Box<T> {

????// T stands for "Type"

????private?T t;

????public?void?set(T t) { this.t = t; }

????public?T get() { return?t; }

}

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

Box<Integer> integerBox = new?Box<Integer>();

Box<Double> doubleBox = new?Box<Double>();

Box<String> stringBox = new?Box<String>();

泛型方法

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

public?class?Util {

????public?static?<K, V> boolean?compare(Pair<K, V> p1, Pair<K, V> p2) {

????????return?p1.getKey().equals(p2.getKey()) &&

???????????????p1.getValue().equals(p2.getValue());

????}

}

public?class?Pair<K, V> {

????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; }

}

我們可以像下面這樣去調用泛型方法：

Pair<Integer, String> p1 = new?Pair<>(1, "apple");

Pair<Integer, String> p2 = new?Pair<>(2, "pear");

boolean?same = Util.<Integer, String>compare(p1, p2);

或者在Java1.7/1.8利用type inference，讓Java自動推導出相應的類型參數：

Pair<Integer, String> p1 = new?Pair<>(1, "apple");

Pair<Integer, String> p2 = new?Pair<>(2, "pear");

boolean?same = Util.compare(p1, p2);

邊界符

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

public?static?<T> 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<T> {

????public?int?compareTo(T o);

}

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

public?static?<T extends Comparable<T>> int?countGreaterThan(T[] anArray, T elem) {

????int?count = 0;

????for?(T e : anArray)

????????if?(e.compareTo(elem) > 0)

????????????++count;

????return?count;

}

通配符

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

public?void?boxTest(Box<Number> n) { /* ... */?}

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

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

class?Fruit {}

class?Apple extends?Fruit {}

class?Orange extends?Fruit {}

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

public?class?GenericReading {

????static?List<Apple> apples = Arrays.asList(new?Apple());

????static?List<Fruit> fruit = Arrays.asList(new?Fruit());

????static?class?Reader<T> {

????????T readExact(List<T> list) {

????????????return?list.get(0);

????????}

????}

????static?void?f1() {

????????Reader<Fruit> fruitReader = new?Reader<Fruit>();

????????// Errors: List<Fruit> cannot be applied to List<Apple>.

????????// Fruit f = fruitReader.readExact(apples);

????}

????public?static?void?main(String[] args) {

????????f1();

????}

}

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

static?class?CovariantReader<T> {

????T readCovariant(List<? extends T> list) {

????????return?list.get(0);

????}

}

static?void?f2() {

????CovariantReader<Fruit> fruitReader = new?CovariantReader<Fruit>();

????Fruit f = fruitReader.readCovariant(fruit);

????Fruit a = fruitReader.readCovariant(apples);

}

public?static?void?main(String[] args) {

????f2();

}

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

PECS原則

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

public?class?GenericsAndCovariance {

????public?static?void?main(String[] args) {

????????// Wildcards allow covariance:

????????List<? extends Fruit> flist = new?ArrayList<Apple>();

????????// 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);

????}

}

更多資料免費分享加群? 120342833?? 驗證回答?? ZZ

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

List<? extends Fruit> flist = new?ArrayList<Fruit>();

List<? extends Fruit> flist = new?ArrayList<Apple>();

List<? extends Fruit> flist = new?ArrayList<Orange>();

當我們嘗試add一個Apple的時候，flist可能指向 new ArrayList<Orange>() ;

當我們嘗試add一個Orange的時候，flist可能指向 new ArrayList<Apple>() ;

當我們嘗試add一個Fruit的時候，這個Fruit可以是任何類型的Fruit，而flist可能只想某種特定類型的Fruit，編譯器無法識別所以會報錯。

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

如果我們要add元素應該怎么做呢？可以使用 <? super T> ：

public?class?GenericWriting {

????static?List<Apple> apples = new?ArrayList<Apple>();

????static?List<Fruit> fruit = new?ArrayList<Fruit>();

????static?<T> void?writeExact(List<T> list, T item) {

????????list.add(item);

????}

????static?void?f1() {

????????writeExact(apples, new?Apple());

????????writeExact(fruit, new?Apple());

????}

????static?<T> void?writeWithWildcard(List<? super?T> 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容器里面的元素了，原因很簡單，我們繼續從編譯器的角度考慮這個問題，對于 List<? super Apple> list ，它可以有下面幾種含義：

List<? super?Apple> list = new?ArrayList<Apple>();

List<? super?Apple> list = new?ArrayList<Fruit>();

List<? super?Apple> list = new?ArrayList<Object>();

當我們嘗試通過list來get一個Apple的時候，可能會get得到一個Fruit，這個Fruit可以是Orange等其他類型的Fruit。

根據上面的例子，我們可以總結出一條規律，”Producer Extends, Consumer Super”：

  • “Producer Extends” – 如果你需要一個只讀List，用它來produce T，那么使用 ? extends T 。

  • “Consumer Super” – 如果你需要一個只寫List，用它來consume T，那么使用 ? super T 。

  • 如果需要同時讀取以及寫入，那么我們就不能使用通配符了。

    如何閱讀過一些Java集合類的源碼，可以發現通常我們會將兩者結合起來一起用，比如像下面這樣：

    public?class?Collections {

    ????public?static?<T> void?copy(List<? super?T> dest, List<? extends T> src) {

    ????????for?(int?i=0; i<src.size(); i++)

    ????????????dest.set(i, src.get(i));

    ????}

    }

    類型擦除

    • 最后編輯于 ：
    ?著作權歸作者所有,轉載或內容合作請聯系作者
    平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

    推薦閱讀更多精彩內容

    • 前言 泛型（Generics）的型變是Java中比較難以理解和使用的部分，“神秘”的通配符，讓我看了幾遍《Java...
      珞澤珈群閱讀 7,940評論 12贊 51
    • 開發人員在使用泛型的時候，很容易根據自己的直覺而犯一些錯誤。比如一個方法如果接收List作為形式參數，那么如果嘗試...
      時待吾閱讀 1,073評論 0贊 3
    • 一、引入泛型機制的原因 假如我們想要實現一個String數組，并且要求它可以動態改變大小，這時我們都會想到用Arr...
      Q南南南Q閱讀 549評論 0贊 1
    • 什么是泛型 泛型，即“參數化類型”。一提到參數，最熟悉的就是定義方法時有形參，然后調用此方法時傳遞實參。那么參數化...
      不知名的蛋撻閱讀 467評論 0贊 1
    • 鵬哥是個不足1.1米的矮人，今年30多歲，喜歡二人轉、愛好文藝，是個業余的藝人。鵬哥是個自卑的人，身患朱儒證內心的...
      覺悟道閱讀 553評論 0贊 0