從一知半解到揭曉Java高階語法—泛型

衍方 發表於 2020-09-10

前言

泛型是Java基礎知識的重點,雖然我們在初學Java的時候,都學過泛型,覺得自己掌握對於Java泛型的使用(全是錯覺),往後的日子,當我們深入去閱讀一些框架原始碼,你就發現了,自己會的只是簡單的使用,卻看不懂別人的泛型程式碼是怎麼寫的,還可以這樣,沒錯,別人寫出來的程式碼那叫藝術,而我......

探討

Java語言為什麼存在著泛型,而像一些動態語言Python,JavaScipt卻沒有泛型的概念?

原因是,像JavaC#這樣的靜態編譯型的語言,它們在傳遞引數的時候,引數的型別,必須是明確的,看一個例子,簡單編寫一個存放int型別的棧—StackInt,程式碼如下:

public class StackInt {

    private int maxSize;
    private int[] items;
    private int top;

    public StackInt(int maxSize){
        this.maxSize = maxSize;
        this.items = new int[maxSize];
        this.top = -1;
    }

    public boolean isFull(){
        return this.top == this.maxSize-1;
    }

    public boolean isNull(){
        return this.top <= -1;
    }

    public boolean push(int value){
        if(this.isFull()){
            return false;
        }
        this.items[++this.top] = value;
        return true;
    }

    public int pop(){
        if(this.isNull()){
            throw new RuntimeException("當前棧中無資料");
        }
        int value = this.items[top];
        --top;
        return value;
    }
}

在這裡使用建構函式初始化一個StackInt物件時,可以傳入String字串嗎?很明顯是不行的,我們要求的是int型別,傳入字串String型別,這樣在語法檢查階段時會報錯的,像Java這樣的靜態編譯型的語言,引數的型別要求是明確的

在這裡插入圖片描述

泛型解決了什麼問題?

引數不安全:引入泛型,能夠在編譯階段找出程式碼的問題,而不是在執行階段

泛型要求在宣告時指定實際資料型別,Java 編譯器在編譯時會對泛型程式碼做強型別檢查,並在程式碼違反型別安全時發出告警。早發現,早治理,把隱患扼殺於搖籃,在編譯時發現並修復錯誤所付出的代價遠比在執行時小。

避免型別轉換:

未使用泛型:

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);    //需要在取出Value的時候進行強制轉換

使用泛型:

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   //不需要強制轉換

重複編碼::通過使用泛型,可以實現通用編碼,可以處理不同型別的集合,並且型別安全且易於閱讀。像上面的StackInt類,我們不能針對每個型別去編寫對應型別的棧,那樣太麻煩了,而泛型的出現就很好的解決了這點

擴充套件

在上面的StackInt類有一些不好的地方,那就是太具體了,不夠抽象,不夠抽象,那麼它的複用性也是不高的,例如,在另外的場景下,我需要的是往棧裡存String型別的字串,或者是其他型別,那麼StackInt類就做不到了,那麼有什麼方法能夠做到呢?再寫一個StackString類,不可能,那樣不得累死。那就只有引入基類Object了,我們改進一下程式碼:

public class StackObject {

    private int maxSize;
    private Object[] items;
    private int top;

    public StackObject(int maxSize){
        this.maxSize = maxSize;
        this.items = new Object[maxSize];
        this.top = -1;
    }

    public boolean isFull(){
        return this.top == this.maxSize-1;
    }

    public boolean isNull(){
        return this.top <= -1;
    }

    public boolean push(Object value){
        if(this.isFull()){
            return false;
        }
        this.items[++this.top] = value;
        return true;
    }

    public Object pop(){
        if(this.isNull()){
            throw new RuntimeException("當前棧中無資料");
        }
        Object value = this.items[top];
        --top;
        return value;
    }
}

使用StackObject可以儲存任意型別的資料,那麼這樣做,又有什麼優點和缺點呢?

優點:StackObject類變得相對抽象了,我們可以往裡面儲存任何型別的資料,這樣就避免了寫一些重複程式碼
在這裡插入圖片描述

缺點:

1、用Object表示的物件是比較抽象的,它失去了型別的特點,那麼我們在做一些運算的時候,可能會頻繁的拆箱裝箱的過程

在這裡插入圖片描述

看上面的例圖,我們理解的認為存放了兩個數值,1234554321,將兩個進行相加,這是很常見的操作,但是報錯了,編譯器給我們的提示是,+操作運算不能用於兩個Object型別,那麼只能對其進行型別轉換,這也是我們上面說到的泛型能解決的問題,我們需要這樣做,int sum = (int)val1 + (int)val2;,同時在涉及拆箱裝箱時,是有一定效能的損耗的,關於拆箱裝箱在這裡不作描述,可以參考我寫過的隨筆—— 深入理解Java之裝箱與拆箱

2、對於我們push進去的值,我們在取出的時候,容易忘記型別轉換,或者不記得它的型別,型別轉換錯誤,這在後面的一些業務可能埋下禍根,例如下面這個場景:直到執行時錯誤才暴露出來,這是不安全的,也是違反軟體開發原則的,應該儘早的在編譯階段就發現問題,解決問題

在這裡插入圖片描述

3、使用Object太過於模糊了,沒有具體型別的意義

最好不要用到Object,因為Object是一切型別的基類,也就是說他把一些型別的特點給抹除了,比如上面存的數字,對於數字來說,加法運算就是它的一個特點,但是用了Object,它就失去了這一特點,失去型別特有的行為

引入泛型

什麼是泛型?

泛型:是被引數化的類或介面,是對型別的約定

泛型類

class name<T1, T2, ..., Tn> { /* ... */ }

一般將泛型中的類名稱為原型,而將 <> 指定的引數稱為型別引數<> 相當於型別的約定,T就是型別,相當於一個佔位符,由我們在呼叫時指定

使用泛型改進一下上面StackObject類,但是,陣列和泛型不能很好地結合。你不能例項化具有引數化型別的陣列,例如下面的程式碼是不合格的:

public StackT(int maxSize){
    this.maxSize = maxSize;
    this.items = new T[maxSize];
    this.top = -1;
}

在這裡插入圖片描述

Java 中不允許直接建立泛型陣列,這是因為相比於C++,C#的語法,Java泛型其實是偽泛型,這點在後面會說到,但是,可以通過建立一個型別擦除的陣列,然後轉型的方式來建立泛型陣列。

private int maxSize;
private T[] items;     
private int top;

public StackT(int maxSize){
    this.maxSize = maxSize;
    this.items = (T[]) new Object[maxSize];
    this.top = -1;
}

實際上,真的需要儲存泛型,還是使用容器更合適,回到原來的程式碼上,需要知道的是,泛型型別不能是基本型別的,需要是包裝類

在這裡插入圖片描述

上面說到了Java 中不允許直接建立泛型陣列,事實上,Java中的泛型我們是很難通new的方式去例項化物件,不僅僅是例項化物件,甚至是獲取T的真實型別也是很難的,當然通過反射的機制還是可以獲取到的,Java獲取真實型別的方式有 3 種,分別是:

1、類名.class

2、物件.getClass

3、class.forName("全限定類名")

但是,在這裡,12的方式都是做不到的,雖然我們在外邊明確的傳入了Integer型別,new StackT<Integer>(3);但是在StackT

類,使用T.class還是獲取不到真實型別的,第 2 種方式的話,並沒有傳入物件,前面也說到是沒有辦法new方式例項化的,而通過反射機制是可以做到的,這裡不作演示,需要了解的話可以參考 —— Java如何獲得泛型類的真實型別Java通過反射獲取泛型的型別

在這裡插入圖片描述

但是在C#中的泛型以及C++的模板,這是很容易做到的,所以說Java的泛型是偽泛型,Java並不是做不到像C#一樣,而是為了遷就老的JDK語法所作出的妥協,至於上面為什麼做不到這樣,這就要說到泛型的型別擦除了。

再說型別擦除之前,先說一下泛型介面,和泛型方法吧

泛型介面

介面也可以宣告泛型,泛型介面語法形式:

public interface Content<T> {
    T text();
}

泛型介面有兩種實現方式:

  • 實現介面的子類明確宣告泛型型別
public class ContentImpl implements Content<Integer> {
    private int text;

    public ContentImpl(int text) {
        this.text = text;
    }

    public static void main(String[] args) {
        ContentImpl one = new ContentImpl(10);
        System.out.print(one.text());
    }
}
// Output:
// 10
  • 實現介面的子類不明確宣告泛型型別
public class ContentImpl<T> implements Content<T> {
    private T text;

    public ContentImpl(T text) {
        this.text = text;
    }

    @Override
    public T text() { return text; }

    public static void main(String[] args) {
        ContentImpl<String> two = new ContentImpl<>("ABC");
        System.out.print(two.text());
    }
}
// Output:
// ABC

泛型方法

泛型方法是引入其自己的型別引數的方法。泛型方法可以是普通方法、靜態方法以及構造方法。

泛型方法語法形式如下:

public <T> T func(T obj) {}

是否擁有泛型方法,與其所在的類是否是泛型沒有關係。

泛型方法的語法包括一個型別引數列表,在尖括號內,它出現在方法的返回型別之前。對於靜態泛型方法,型別引數部分必須出現在方法的返回型別之前。型別引數能被用來宣告返回值型別,並且能作為泛型方法得到的實際型別引數的佔位符。

使用泛型方法的時候,通常不必指明型別引數,因為編譯器會為我們找出具體的型別。這稱為型別引數推斷(type argument inference)。型別推斷只對賦值操作有效,其他時候並不起作用。如果將一個泛型方法呼叫的結果作為引數,傳遞給另一個方法,這時編譯器並不會執行推斷。編譯器會認為:呼叫泛型方法後,其返回值被賦給一個 Object 型別的變數。

public class GenericsMethod {
    public static <T> void printClass(T obj) {
        System.out.println(obj.getClass().toString());
    }

    public static void main(String[] args) {
        printClass("abc");
        printClass(10);
    }
}
// Output:
// class java.lang.String
// class java.lang.Integer

泛型方法中也可以使用可變引數列表

public class GenericVarargsMethod {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<T>();
        Collections.addAll(result, args);
        return result;
    }

    public static void main(String[] args) {
        List<String> ls = makeList("A");
        System.out.println(ls);
        ls = makeList("A", "B", "C");
        System.out.println(ls);
    }
}
// Output:
// [A]
// [A, B, C]

型別擦除

事實上,Java的執行大致可以分為兩個階段,編譯階段執行階段

那麼對於Java泛型來說,當編譯階段過後,泛型 T 是已經被擦除了,所以在執行階段,它已經丟失了 T 的具體資訊,而我們去例項化一個物件的時候,比如T c = new T();,它的發生時機是在執行階段,而在執行階段,你要new T(),就需要知道 T 的具體型別,實際上這時候 T是被替換成Integer了,而JVM是不知道T的型別的,所以是沒有辦法例項化的。

那麼,型別擦除做了什麼呢?它做了以下工作:

  • 把泛型中的所有型別引數替換為 Object,如果指定型別邊界,則使用型別邊界來替換。因此,生成的位元組碼僅包含普通的類,介面和方法。
  • 擦除出現的型別宣告,即去掉 <> 的內容。比如 T get() 方法宣告就變成了 Object get()List<String> 就變成了 List。如有必要,插入型別轉換以保持型別安全。
  • 生成橋接方法以保留擴充套件泛型型別中的多型性。型別擦除確保不為引數化型別建立新類;因此,泛型不會產生執行時開銷。

讓我們來看一個示例:

import java.util.*;

public class ErasedTypeEquivalence {

    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2);
    }

}
/* Output:
true
*/

ArrayList<String>ArrayList<Integer> 應該是不同的型別。不同的型別會有不同的行為。例如,如果嘗試向 ArrayList<String> 中放入一個 Integer,所得到的行為(失敗)和 向 ArrayList<Integer> 中放入一個 Integer 所得到的行為(成功)完全不同。但是結果輸出的是true,這意味著使用泛型時,任何具體的型別資訊都被擦除了,ArrayList<Object>ArrayList<Integer> 在執行時,JVM 將它們視為同一型別class java.util.ArrayList

再用一個例子來對於該謎題的補充:

import java.util.*;

class Frob {}
class Fnorkle {}
class Quark<Q> {}

class Particle<POSITION, MOMENTUM> {}

public class LostInformation {

    public static void main(String[] args) {
        
        List<Frob> list = new ArrayList<>();
        Map<Frob, Fnorkle> map = new HashMap<>();
        Quark<Fnorkle> quark = new Quark<>();
        Particle<Long, Double> p = new Particle<>();
        
        System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
    }

}
/* Output:
[E]
[K,V]
[Q]
[POSITION,MOMENTUM]
*/

根據 JDK 文件,Class.getTypeParameters() “返回一個 TypeVariable 物件陣列,表示泛型宣告中宣告的型別引數...” 這暗示你可以發現這些引數型別。但是正如上例中輸出所示,你只能看到用作引數佔位符的識別符號,這並非有用的資訊。

殘酷的現實是:在泛型程式碼內部,無法獲取任何有關泛型引數型別的資訊。

以上兩個例子皆出《Java 程式設計思想》第五版 —— On Java 8中的例子,本文藉助該例子,試圖講清楚Java泛型是使用型別擦除這裡機制實現的,能力不足,有錯誤的地方,還請指正。關於On Java 8一書,已在github上開源,並有熱心的夥伴將之翻譯成中文,現在給出閱讀地址,On Java 8

擦除的問題

擦除的代價是顯著的。泛型不能用於顯式地引用執行時型別的操作中,例如轉型、instanceof 操作和 new 表示式。因為所有關於引數的型別資訊都丟失了,當你在編寫泛型程式碼時,必須時刻提醒自己,你只是看起來擁有有關引數的型別資訊而已。

考慮如下的程式碼段:

class Foo<T> {
    T var;
}

看上去當你建立一個 Foo 例項時:

Foo<Cat> f = new Foo<>();

class Foo 中的程式碼應該知道現在工作於 Cat 之上。泛型語法也在強烈暗示整個類中所有 T 出現的地方都被替換,就像在 C++ 中一樣。但是事實並非如此,當你在編寫這個類的程式碼時,必須提醒自己:“不,這只是一個 Object“。

繼承問題

泛型時基於型別擦除實現的,所以,泛型型別無法向上轉型

向上轉型是指用子類例項去初始化父類,這是物件導向中多型的重要表現。

在這裡插入圖片描述

Integer 繼承了 ObjectArrayList 繼承了 List;但是 List<Interger> 卻並非繼承了 List<Object>

這是因為,泛型類並沒有自己獨有的 Class 類物件。比如:並不存在 List<Object>.class 或是 List<Interger>.class,Java 編譯器會將二者都視為 List.class

如何解決上面所產生的問題:

其實並不一定要通過new的方式去例項化,我們可以通過顯式的傳入源類,一個Class<T> clazz的物件來補償擦除,例如instanceof 操作,在程式中嘗試使用 instanceof 將會失敗。型別標籤可以使用動態 isInstance() ,這樣改進程式碼:

public class Improve<T> {
	
    //錯誤方法
    public boolean  f(Object arg) {
        // error: illegal generic type for instanceof
        if (arg instanceof T) {
            return true;
        }
        return false;
    }
    //改進方法
    Class<T> clazz;
    
	public Improve(Class<T> clazz) {
        this.clazz = clazz;
    }

    public boolean f(Object arg) {
        return kind.isInstance(arg);
    }
}

例項化:

試圖在 new T() 是行不通的,部分原因是由於擦除,部分原因是編譯器無法驗證 T 是否具有預設(無參)建構函式。

Java 中的解決方案是傳入一個工廠物件,並使用該物件建立新例項。方便的工廠物件只是 Class 物件,因此,如果使用型別標記,則可以使用 newInstance() 建立該型別的新物件:

class Improve<T> {
    Class<T> kind;

    Improve(Class<T> kind) {
        this.kind = kind;
    }
    
    public T get(){
        try {
            return kind.newInstance();
        } catch (InstantiationException |
                IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

class Employee {
    @Override
    public String toString() {
        return "Employee";
    }
}

public class InstantiateGenericType {
    public static void main(String[] args) {
        Improve<Employee> fe = new Improve<>(Employee.class);
        System.out.println(fe.get());
    }
}
/* Output:
Employee
*/

通過這樣改進程式碼,可以實現建立物件的例項,但是要注意的是,newInstance();方法呼叫無參建構函式的,如果傳入的型別,沒有無參構造的話,是會丟擲InstantiationException異常的。

泛型陣列

泛型陣列這部分,我們在上面說到可以通過建立一個型別擦除的陣列,然後轉型的方式來建立泛型陣列,這次我們可以通過顯式的傳入源類的方式來編寫StackT類,解決建立泛型陣列的問題,程式碼如下:

public class StackT<T> {

    private int maxSize;
    private T[] items;
    private int top;

    public StackT(int maxSize, Class<T> clazz){
        this.maxSize = maxSize;
        this.items = this.createArray(clazz);
        this.top = -1;
    }

    public boolean isFull(){
        return this.top == this.maxSize-1;
    }

    public boolean isNull(){
        return this.top <= -1;
    }

    public boolean push(T value){
        if(this.isFull()){
            return false;
        }
        this.items[++this.top] = value;
        return true;
    }

    public T pop(){
        if(this.isNull()){
            throw new RuntimeException("當前棧中無資料");
        }
        T value = this.items[top];
        --top;
        return value;
    }

    private T[] createArray(Class<T> clazz){
        T[] array =(T[])Array.newInstance(clazz, this.maxSize);
        return array;
    }

}

邊界

有時您可能希望限制可在引數化型別中用作型別引數的型別。型別邊界可以對泛型的型別引數設定限制條件。例如,對數字進行操作的方法可能只想接受 Number 或其子類的例項。

要宣告有界型別引數,請列出型別引數的名稱,然後是 extends 關鍵字,後跟其限制類或介面。

型別邊界的語法形式如下:

<T extends XXX>

示例:

public class GenericsExtendsDemo01 {
    static <T extends Comparable<T>> T max(T x, T y, T z) {
        T max = x; // 假設x是初始最大值
        if (y.compareTo(max) > 0) {
            max = y; //y 更大
        }
        if (z.compareTo(max) > 0) {
            max = z; // 現在 z 更大
        }
        return max; // 返回最大物件
    }

    public static void main(String[] args) {
        System.out.println(max(3, 4, 5));
        System.out.println(max(6.6, 8.8, 7.7));
        System.out.println(max("pear", "apple", "orange"));
    }
}
// Output:
// 5
// 8.8
// pear

示例說明:

上面的示例宣告瞭一個泛型方法,型別引數 T extends Comparable<T> 表明傳入方法中的型別必須實現了 Comparable 介面。

型別邊界可以設定多個,語法形式如下:

<T extends B1 & B2 & B3>

注意:extends 關鍵字後面的第一個型別引數可以是類或介面,其他型別引數只能是介面。

萬用字元

萬用字元是Java泛型中的一個非常重要的知識點。很多時候,我們其實不是很理解萬用字元和泛型型別T區別,容易混淆在一起,其實還是很好理解的,T 都表示不確定的型別,區別在於我們可以對 T 進行操作,但是對 不行,比如如下這種 :

// 可以
T t = operate();
// 不可以
? car = operate();

但是這個並不是我們混淆的原因,雖然T 都表示不確定的型別,T 通常用於泛型類和泛型方法的定義,通常用於泛型方法的呼叫程式碼和形參,不能用於定義類和泛型方法。用程式碼解釋一下,回到文章最初說的棧類StackT,我們以這個為基礎來解釋,上面的觀點:

public class Why {
    public static void main(String[] args) {

        StackT<Integer> stackT = new StackT<>(3, Integer.class);
        stackT.push(8);
        StackT<String> stackT1 = new StackT<>(3, String.class);
        stackT1.push("7");
        test(stackT1);

    }
    public static void test(StackT stackT){
        System.out.println(stackT.pop());
    }
}
// Output: 8

以我們編寫的StackT類,進行測試,編寫一個test方法,傳入引數型別StackT,上面的程式正常輸出字串"7" ,這沒有什麼問題,問題在這裡失去了泛型的限定,傳進去的實參StackT1,是被我們限定為StackT<String> ,但是我們通過編譯器可以看到stackT.pop()出來的物件,並沒有String型別的特有方法,也就是說,它其實是Object

在這裡插入圖片描述

那麼我們就需要修改test方法的形參,改為:

public static void test(StackT<String> stackT){
    System.out.println(stackT.pop());
}

這樣子就回到了我們問題的本質來了,將形參修改為StackT<String>,這起到了泛型的限定作用,但是會出現這樣的問題,如果我們需要向該方法傳入StackT<Integer>型別的物件 stackT是,因為方法形參限定了StackT<String>,,這時候就報錯了

在這裡插入圖片描述

這個時候就是萬用字元?起作用了,將方法形參改為StackT<?>就可以了,這也就確定了我們剛剛的結論,萬用字元通常是用於泛型傳參,而不是泛型類的定義。

public static void test(StackT<?> stackT){
    System.out.println(stackT.pop());
}

但是這種用法我們通常也不會去用,因為它還是失去了型別的特點,即當無界泛型萬用字元作為形參時,作為呼叫方,並不限定傳遞的實際引數型別。但是,在方法內部,泛型類的引數和返回值為泛型的方法,不能使用!

在這裡插入圖片描述

這裡,StackT.push就不能用了,因為我並不知道?傳的是Integer還是String ,還是其他型別,所以是會報錯的。

但是我們有時候是有這樣的需求的,我們在接收泛型棧StackT作為形參的時候,我想表達一種約束的關係,但是又不像StackT<String>一樣,約束的比較死板,而Java是物件導向的語言,那麼就會有繼承的機制,我想要的約束關係是我能接收的泛型棧的型別都是Number類的派生類,即不會像?無界萬用字元一樣失去類的特徵,又不會像StackT<String>約束的很死,這就引出了上界萬用字元的概念。

上界萬用字元

可以使用上界萬用字元來縮小型別引數的型別範圍。

它的語法形式為:<? extends Number>

public class Why {
    public static void main(String[] args) {

        StackT<Integer> stackT = new StackT<>(3, Integer.class);
        stackT.push(8);
        StackT<String> stackT1 = new StackT<>(3, String.class);
        stackT1.push("7");
        StackT<Double> stackT2 = new StackT<>(3, Double.class);
        
        //通過
        test(stackT);
        test(stackT2);
        //error
        test(stackT1);

    }
    
    public static void test(StackT<? extends Number> stackT){

        System.out.println(stackT.pop());
    }
}

這樣就實現了一類型別的限定,但是需求變更了,我現在希望的約束關係是我能接收的泛型棧的型別都是Number類的父類,或者父類的父類,那麼有上界,自然就有下界

下界萬用字元

下界萬用字元將未知型別限制為該型別的特定型別或超類型別。

注意:上界萬用字元和下界萬用字元不能同時使用

它的語法形式為:<? super Number>

public class Why {
    public static void main(String[] args) {

        StackT<Number> stackT1 = new StackT<>(3, Number.class);
        stackT1.push(8);
        StackT<Double> stackT2 = new StackT<>(3, Double.class);
        StackT<Object> stackT3 = new StackT<>(3, Object.class);
        //通過
        test(stackT1);
        test(stackT3);
        //error
        test(stackT2);

    }

    public static void test(StackT<? super Number> stackT){

        System.out.println(stackT.pop());
    }
}

這樣子的話,就確保了我們的test方法只接收Number型別以上的方法。泛型的各種高階語法可能在寫業務程式碼的時候可以規避,但是如果你要去寫一些框架的時候,由於你不知道框架的使用者的使用場景,那麼掌握泛型的高階語法就很有用了。

萬用字元和向上轉型

前面,我們提到:泛型不能向上轉型。但是,我們可以通過使用萬用字元來向上轉型

public class GenericsWildcardDemo {
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        List<Number> numList = intList;  // Error

        List<? extends Integer> intList2 = new ArrayList<>();
        List<? extends Number> numList2 = intList2;  // OK
    }
}

萬用字元邊界問題,關於一些更加深入的解惑可以參考整理的轉載的文章——Java泛型解惑之上下萬用字元

泛型約束

Pair<int, char> p = new Pair<>(8, 'a');  // 編譯錯誤
public static <E> void append(List<E> list) {
    E elem = new E();  // 編譯錯誤
    list.add(elem);
}
public class MobileDevice<T> {
    private static T os; // error

    // ...
}
public static <E> void rtti(List<E> list) {
    if (list instanceof ArrayList<Integer>) {  // 編譯錯誤
        // ...
    }
}
List<Integer> li = new ArrayList<>();
List<Number>  ln = (List<Number>) li;  // 編譯錯誤
List<Integer>[] arrayOfLists = new List<Integer>[2];  // 編譯錯誤
// Extends Throwable indirectly
class MathException<T> extends Exception { /* ... */ }    // 編譯錯誤

// Extends Throwable directly
class QueueFullException<T> extends Throwable { /* ... */ // 編譯錯誤
public static <T extends Exception, J> void execute(List<J> jobs) {
    try {
        for (J job : jobs)
            // ...
    } catch (T e) {   // compile-time error
        // ...
    }
}
public class Example {
    public void print(Set<String> strSet) { }
    public void print(Set<Integer> intSet) { } // 編譯錯誤
}

實踐總結

泛型命名

泛型一些約定俗成的命名:

  • E - Element
  • K - Key
  • N - Number
  • T - Type
  • V - Value
  • S,U,V etc. - 2nd, 3rd, 4th types

使用泛型的建議

  • 消除型別檢查告警
  • List 優先於陣列
  • 優先考慮使用泛型來提高程式碼通用性
  • 優先考慮泛型方法來限定泛型的範圍
  • 利用有限制萬用字元來提升 API 的靈活性
  • 優先考慮型別安全的異構容器

參考資料:

深入理解 Java 泛型

On Java 8

Java泛型解惑之 extends T>和 super T>上下界限

7月的直播課——Java 高階語法—泛型