摘要

本文根據《Java核心技術 卷一》一書的第八章總結而成，部分文章摘抄書內，作為個人筆記。
文章不會過於深入，望讀者參考便好。

為什麼要使用泛型程式設計

泛型程式設計（Generic programming) 意味著編寫的程式碼可以被很多不同型別的物件所重用。

型別引數的好處

在沒有泛型類之前，ArrayList類只維護一個Object引用的陣列：

public class ArrayList {
   private Object[] elementData; // 用於存放資料
   public Object get(int i) { . . . }
   public void add(Object o) { . . . }
     ...
}
 

問題

1.獲取一個值時必須進行強制型別轉換
2.這裡沒有錯誤檢査。可以向陣列列表中新增任何類的物件，如果陣列的型別不一致，將 get 的結果進行強制強制型別，就會錯誤。

泛型提供了一個更好的解決方案： 型別引數：

ArrayList<String> array = new ArrayList<String>():

利用型別引數的資訊，我們就可以在新增資料的時候保持型別統一，呼叫get方法時候也不需要進行強制型別轉換，因為我們在初始化的時候就定義了型別，編譯器識別返回值的型別就會幫我們轉換該型別。

定義一個簡單泛型類

public class Pair<T> {
    private T num;

    public Pair(T num) { this.num = num; }
    public T getNum() { return num; }
    public void setNum(T num) { this.num = num; }
}
 

我們可以看到，在Pair類名後面添加了一個，這個是泛型類的型別變數，而且還可以有多個型別變數，如

public class Pair<T,U> {
    ...
}

如果我們例項化Pair類，例如：

new Pair<String>;

那麼我們就可以把上述的Pair類想象成如下：

public class Pair<String> {
    private String num;

    public Pair(String num) { this.num = num; }
    public String getNum() { return num; }
    public void setNum(String num) { this.num = num; }
}
 

是不是很簡單呢？在Java庫中，使用變數E表示集合的元素型別，K和V分別表示表的關鍵字與值的型別，T、U、S表示任意型別。

泛型方法

定義一個帶有型別引數的方法

    public static <T> T getMiddle(T... a) {
        return a[a.length / 2];
    }

可以看到型別變數(< T >)放在修飾符( public static )的後面，返回型別（T）的前面。泛型方法可以定義在普通類或泛型類中。

型別變數的限定

如果我們需要對型別變數加以約束，例如：傳入的變數必須實現Comparable介面，因為需要該變數呼叫compareTo的方法。這樣我們就可以使用extends關鍵字對變數進行限定。

    public <T extends Comparable> T max(T a) {
        a.compareTo(...);
        ...
    }

無論變數需要限定為繼承某個類或者實現某個介面，都是使用extends關鍵字進行限定。

泛型程式碼和虛擬機器

型別擦除

無論我們在程式碼中怎麼定義一個泛型類、泛型方法，都提供了一個相應的原始型別。原始型別的名字就是刪去型別引數後的泛型類姓名。如 <T> 的原始型別為 Object，<T extends MyClass>的原始型別為MyClass。
程式碼就像下面這樣：

public class Pair<T> {
    private T property;

    public Pair(T property) {
        this.property = property;
    }
}

型別擦除後：

public class Pair<Object> {
    private Object property;

    public Pair(Object property) {
        this.property = property;
    }
}

翻譯泛型表示式

如果擦除返回型別，編譯器會插入強制型別轉換，就像下面這樣：

Pair<Employee> buddies = . .
Employee buddy = buddies.getFirst()；

擦除getFirst的返回型別後將返回Object型別，但是編譯器將自動幫我們強制型別轉換為Employee。
所以：編譯器把這個方法執行操作分為兩條指令：

對原始方法Pair.getFirst的呼叫
將返回的Object型別強制轉換為Employee型別

小節總結：

虛擬機器中沒有泛型，只有普通的類和方法
所有的型別引數都用他們的限定型別替換
為保持型別安全性，必要時插入強制型別轉換
橋方法被合成來保持多型（本文沒有講到，不過橋方法可以忽略，Java編寫不規範才會有橋方法生成）

約束與侷限性

不能用基本型別例項化型別引數

不可以用八大基本資料型別去例項化型別引數，你也沒見過ArrayList<int>這樣的程式碼吧。只有ArrayList<Integer>。原因是因為基本資料型別是不屬於Object的。所以只能用他們的包裝型別替換。

執行時型別查詢只適用於原始型別

所有的型別查詢只產生原始型別，因為在虛擬機器沒有所謂的泛型型別。
例如：

    Pair<String> pair = new Pair<String>("johnson");
    if (pair instanceof Pair<String>) {} // Error
    if (pair instanceof Pair<T>) {} // Error
    if (pair instanceof Pair) {} // Pass

不能建立引數化型別的陣列

    Pair<String>[] pairs = new Pair<String>[10]; //error

為什麼不能這樣定義呢？因pairs的型別是Pair[]，可以轉換為Object[]，如果試圖儲存其他型別的元素，就會丟擲ArrayStoreException異常，

    pairs[0] = 10L; //拋異常

總之一句話，不嚴謹。所以不能建立引數化型別的陣列。

不能例項化型別變數

不能使用 new T(...)、new T[...] 或 T.class。因為型別擦除後，T將變成Object，而且我們肯定不是希望例項化Object。
不過在Java8之後，我們可以使用Supplier<T>介面實現，這是一個函式式介面，表示一個無引數而且有返回型別為T的函式：

public class Pair<T> {
    private T first;
    private T second;

    private Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public static <T> Pair<T> makePair(Supplier<T> constr) {
        return new Pair<>(constr.get(), constr.get());
    }
    
    public static void main(String[] args) {
        Pair<String> pair = Pair.makePair(String::new);
    }
}

泛型類中的靜態上下文中型別變數無效

不能在靜態域或方法中引用型別變數。例如：

public class Pair<T> {
    private static T instance; //Error

    public static T getInstance() { //Error
        if (instance == null) 
            instance = new Pair<T>();
        return instance;
    }
}

因為類中的型別變數（<T>）是在物件中的作用域有效，而不是在類中的作用域有效。如果要使用泛型方法，可以參照文章上面的泛型方法哦~

不能丟擲或捕獲泛型類的例項

即不能丟擲也不能捕獲泛型類的物件，甚至擴充套件Throwable都是不合法的：

public class Pair<String> extend Exceotion {} //Error

public static <T extends Throwable> void doWork(Class<T> t) {
    try {
        ...
    } catch (T e) { //Error
        ...
    }
}

但是在丟擲異常後對異常使用型別變數是允許的（個人感覺沒見過這樣的程式碼）。

public static <T extends Throwable> void doWork(Class<T> t) throw T { //Pass
    try {
        ...
    } catch (Exception e) {
        throw e;
    }
}

泛型型別的繼承規則

如Manager類繼承Employee類。但是Pair<Employee>和Pair<Manager>是沒有關聯的。就像下面的程式碼，就會提示報錯，傳遞失敗：

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<Employee> employeePair = managerPair; //Error

萬用字元型別

萬用字元概念

萬用字元型別中，允許型別引數變化，使用 ? 標識萬用字元型別：

Pair<? extends Employee>

若Pair類如下

public class Pair<T> {
    private T object;

    public void setObject(T object) {
        this.object = object;
    }
}

那麼使用萬用字元可以解決泛型型別的繼承規則問題，如：

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<? extends Employee> employeePair = managerPair; //Pass
        Manager manager = new Manager();
        employeePair.setObject(manager); //Error

使用<? extends Employee>，編譯器只知道employeePair 是Employee的子類，但是不清楚具體是什麼子類，所以最後一步employeePair.setObject(manager)不能執行。

萬用字元的超型別限定

萬用字元還有一個附加的能力，就是可以指定一個超型別限定，如：

public class Pair<T> [
    ...
    public static void salary(Pair<? super Manager> result) {
        //...
    }
}

<? super Manager>這個萬用字元為Manager的所有超型別（包含Manger），例如：

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<Employee> employeePair = new Pair<Employee>();

        Pair.salary(managerPair); //Pass
        Pair.salary(employeePair); //Pass

        // 假如 ManagerChild為Manager子類
        Pair<ManagerChild> managerChildPair = new Pair<ManagerChild>();
        Pair.salary(managerChildPair); //Error

無限定萬用字元

無限定萬用字元，如：Pair<?>，當我們不需要理會他的實際型別時候，就可以使用無限定萬用字元，上程式碼：

    public static boolean hasNull(Pair<?> pair) {
        return pair.getObject() == null;
    }

說實話，萬用字元搞得我頭昏腦脹的，反覆不斷地看文章，才開始慢慢看懂，我太難了。。。


文章到這裡就結束啦，不知道各位小夥伴看懂了沒，沒看懂的話可能是我的功底和文章寫作能力還有待提高，小夥伴們也可以去看一下《Java核心技術 卷一》這本書呢，感覺還是挺不錯的。最近把這本書撿起來看也是發現基礎是非常重要的，先把基礎沉澱好了，再學習其他的技術點也會更容易入手，也會知其然知其所然。最近非常喜歡的一句話，送給大家：“萬丈高樓平地起，勿在浮沙築高臺”。

個人部落格網址： https://colablog.cn/

如果我的文章幫助到您，可以關注我的微信公眾號，第一時間分享文章給您

相關推薦