大部分語言都支援泛型，泛型是一種語言機制，各種語言的實現機制都不太一樣，例如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 滿天飛。
