大部分語言都支持泛型，泛型是一種語言機制，各種語言的實現機制都不太一樣，例如C++使用模板方式來實現泛型，而 Java 中用類型擦除機制來實現泛型。

什么是泛型

在 Java 中，不會泛型，寸步難行。泛型可能是一個 Java 初學者需要攻克的第一個難點。隨便跟著一門教程或 任何一本《Java入門到精通》，前面關于變量、關鍵字、語法（if、while、for等等）這些基本上是一看就懂，而當內容來到泛型的時候，大部分人可能就突然感覺沒那么輕松了。

如果沒有編程經驗的話，可能需要練習一段時間才能完全掌握泛型編程概念和技巧，這么說吧，有些人寫了好幾年代碼，碰到泛型的時候可能還是不太熟練。

說到Java泛型，最明顯的標志就是 <> 。

泛型是什么呢？通俗的說就是一個類型是沒有固定類型的，即可以是Integer 也可以是 Long，還可能是你自定義的類。

泛型使類型（類和接口）能夠在定義類、接口和方法時成為參數。與方法聲明中使用的更熟悉的形式參數非常相似，類型參數為您提供了一種通過不同輸入重復使用相同代碼的方法。區別在于形式參數的輸入是值，而類型參數的輸入是類型。

例如在類定義中使用泛型，最常見的 ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//... code
}

例如在方法參數中使用泛型，來一個復雜的例子

public static <T extends Number & Comparable<T>, U extends List<T>, R extends T> R complexMethod(U list, T element) {

}

在這個例子中，有兩個傳入參數 U list, T element，而這兩個參數需要在方法的返回類型前用<>做出說明，也就是 <T extends Number & Comparable<T>, U extends List<T>, R extends T>這一部分。

返回值也是一個泛型 R。

為什么是 T、U、R

經常看到泛型類型用 T、U、R，還有K、V 這樣的符號表示。我們肯定知道不用T也完全沒問題，用 X 也可以。

之所以這么統一是因為這是官方比較推薦的寫法，推薦的規則如下：

• E - 表示一個元素，例如集合元素、數組元素
• K - 表示一個 Key，鍵值對經常用到，與之對應的是 V
• V - 表示一個 Value，鍵值對經常用
• N - 表示 Number（數字類型）
• T - 這個見得最多，表示一個類型 Type，不管是基礎類型還是自定義的類

泛型的作用

前面也說了，當一個參數預期可能有多種類型的時候，就會用到泛型，那既然是類型不確定，那直接用 Object 不就行了嗎，何必費事兒呢？一會兒講到類型擦除的時候會發現，本身類型擦除的核心就是把泛型類型轉為 Object。但是這是編譯器干的，為了給JVM看的。而作為開發者和編譯器，使用泛型還是有很大好處的。

1、在編譯時提供更嚴格的類型檢查，如果代碼違反類型安全，編譯器可以及時發現，而不是等到運行的時候拋出運行時異常。

2、使程序員能夠實現通用算法。通過使用泛型，程序員可以實現適用于不同類型集合的泛型算法，可以自定義，并且類型安全且更易于閱讀。

例如下面這個方法，只接受Number 類型的參數，用來比較兩數的大小。

public static <T extends Number> Boolean compare(T first, T second) {
        double firstValue = first.doubleValue();
        double secondValue = second.doubleValue();

        return firstValue > secondValue;
    }

3、消除不必要的類型轉換。

例如下面不用泛型的情況，每次取數據的時候都要轉換一下類型。

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

而用了泛型后，就不用自己轉換了。

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);

類型擦除

Java 中的泛型實現可以說就是用的類型擦除原理。通俗一點說，類型只在編譯期存在，在運行時就不在了，都變為了 Object，一視同仁。

在我們寫好代碼進行編譯時，編譯器會將泛型參數的類型進行替換，大部分情況下會將類型替換為 0bject 類型。這種行為模式用類型擦除來描述就非常形象。

類型擦除原理

在類型擦除過程中，Java 編譯器會擦除所有類型參數，如果類型參數有界，則用其第一個邊界替換每個參數；如果類型參數無界，則用 Object 替換。

在類型擦除過程中，編譯器會按照以下規則來處理泛型類型參數：

如果類型參數有界（bounded type），即使用了extends關鍵字限定了類型的上界，例如<T extends Number>，則編譯器會用該類型的第一個邊界來替換類型參數。

例如下面這個例子，泛型 T 繼承了Number類型，又實現了 Displayable 接口（沒錯，泛型可以這樣定義）

interface Displayable {
    void display();
}

public class Result<T extends Number & Displayable> {
    private T value;

    public Result(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
    
 public void show() {
        value.display();
    }
}

在編譯器進行類型擦除后會變成下面這樣，因為 T 的上限是 Number，所以直接將 T 替換為 Number。

public class Result {
    private Number value;

    public Result(Number value) {
        this.value = value;
    }

    public Number getValue() {
        return value;
    }
}

如果類型參數無界（unbounded type），即沒有限定類型的上界，例如<T>，則編譯器會用Object類型來替換類型參數。

例如下面方法，沒有指定類型上限類型。

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

經過編譯器的擦除處理后，就變成下面這樣，都替換成了 Object。

public static int count(Object[] anArray, Object elem) {
    int cnt = 0;
    for (Object e : anArray)
        if (e.equals(elem))
            ++cnt;
        return cnt;
}

橋接方法

來看一下下面這段代碼

public class Node<T> {

    public T data;

    public Node(T data) { this.data = data; }

    public void setData(T data) {
        this.data = data;
    }
}

public class SubNode extends Node<Integer> {
    public SubNode(Integer data) { super(data); }

    public void setData(Integer data) {
        super.setData(data);
    }
    
 public static void main(String[] args) {
        SubNode subNode = new SubNode(8);
        Node node = subNode;
        node.setData("Hello");
        Integer x = subNode.data;
    }

}

這段代碼大家一看就知道肯定是有問題的，運行的時候會出現 ClassCastException，但是編譯是可以通過的。

而運行時出現錯誤的代碼是 node.setData("Hello");這一行，但是經過前面對類型擦除的了解，Node 類的 setData 參數肯定被擦除成了 Object 類型了，既然是 Object，那Integer 和 String 都滿足啊，為啥還會報錯呢。

這就要說到橋接了。

當編譯器對泛型擴展的類或接口進行編譯處理的時候，會根據實際的類型進行方法的橋接處理。什么意思呢，還是拿上面的 Node 和 SubNode 類說明。

類型擦除后的代碼是下面這樣的，多了一個橋接方法。

public class Node {

    public Object data;

    public Node(Object data) { this.data = data; }

    public void setData(Object data) {
        this.data = data;
    }
}

public class SubNode extends Node {

    public SubNode(Integer data) { super(data); }

 /**
 ** 橋接方法
 **/
 public void setData(Object data) {
        setData((Integer) data);
    }

    public void setData(Integer data) {
        super.setData(data);
    }
}

為什么需要這個橋接方法呢？

Node 類的 setData 方法入參是 Object 類型。

public void setData(Object data) {
    this.data = data;
}

而 SubNode 的setData 方法入參是 Integer。

public void setData(Integer data) {
 super.setData(data);
}

所以，SubNode 的 setData 方法并不會重寫父類 Node 的setData 方法，而想要重寫的話，就必須讓 SubNode 的setData 的入參也是 Object，這就是橋接方法的由來。

public void setData(Object data) {
 setData((Integer) data);
}

這樣一來重寫父類的方法，但是要把參數強轉成 Integer。

前面說的 node.setData("Hello");這一行會報錯，那大家就知道為什么了吧，是因為把 Hello強轉為 Integer 的時候出現的錯誤。

總結

正是類型擦除的機制幫助 Java 實現了泛型編程，讓我們作為開發者能夠更好的了解和控制我們正在使用類型的是什么，而不是 Object 滿天飛。