本文將從以下四個方面來系統的講解一下泛型，基本上涵蓋了泛型的主體內容。
- 什么是泛型？
- 為什么要使用泛型？
- 如何使用泛型？
- 泛型的特性
1. 什么是泛型？
泛型的英文是Generics，是指在定義方法、接口或類的時候，不預先指定具體的類型，而使用的時候再指定一個類型的一個特性。
寫過Java代碼的同學應該知道，我們在定義方法、接口或類的時候，都要指定一個具體的類型。比如：
public class test {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
上面代碼就定義了字段name的類型為String，方法getName的返回類型為String，這種寫法就是預先指定了具體的類型。而泛型就是不預先指定具體的類型。
Java中有一個類型叫ArrayList，相當於一個可變長度的數組。在ArrayList類型中就沒有預先指定具體的類型。因為數組可以存放任何類型的數據，如果要預先指定一個數組類型的話，那要滿足大家對各種類型的需求，就要寫很多類型的ArrayList，要為每個class寫一個單獨的ArrayList，比如：
-
IntegerArrayList -
StringArrayList -
FloatArrayList -
LongArrayList -
...
這顯然不太現實，因為class有上千種，還有自己定義的class。那么在ArrayList中預先指定具體的類型就無法滿足需求。這個時候就需要使用泛型，即不指定存儲數據的具體的類型，這個類型由使用者決定。
為了解決類型的問題，我們必須把ArrayList變成一種模板：ArrayList<T>，代碼如下：
public class ArrayList<T> {
private T[] array;
private int size;
public void add(T e) {...}
public void remove(int index) {...}
public T get(int index) {...}
}
T可以是任何class，這樣一來，我們就實現了：編寫一次模版，可以創建任意類型的ArrayList：
// 創建可以存儲String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 創建可以存儲Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 創建可以存儲Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();
因此，泛型也可以說是定義一種模板，例如ArrayList<T>，然后在代碼中為用到的類創建對應的ArrayList<類型>。（泛型是指在定義方法、接口或類的時候，不預先指定具體的類型，而使用的時候再指定一個類型的一個特性。）后面這種定義可能會更好理解其本質。
更為官方的定義是：泛型指“參數化類型”。泛型的本質是為了參數化類型（將類型參數化傳遞）（在不創建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數據類型被指定為一個參數，這種參數類型，可以在類、接口和方法中，分別被稱為泛型類，泛型接口，泛型方法。
2. 為什么要使用泛型？
參考自：Oracle 泛型文檔
與非泛型的代碼相比，使用泛型的代碼具有很多優點：
-
在編譯時會有更強的類型檢查
Java編譯器對泛型代碼進行強類型檢查，如果代碼違反類型安全，則會發出錯誤。修復編譯時的錯誤比修復運行時的錯誤會更加簡單，運行時的錯誤會更難找到。
說人話就是，使用泛型時，編譯器會對輸入的類型的進行檢查，類型與聲明的類型不一致時就會報錯。而不使用泛型，編譯器可能就檢測不到這個類型錯誤，就會在運行的時候報錯。
-
消除類型轉換
下面的代碼是沒有使用泛型的情況，這時候需要對類型進行轉換
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); // no cast -
可以實現更通用的算法
通過使用泛型，程序員可以對不同類型的集合進行自定義操作以實現通用算法，並且代碼類型會更加安全、代碼更易讀
3. 如何使用泛型？
還是以ArrayList為例，如果不定義泛型類型時，泛型類型此時就是Object：
// 編譯器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);
此時，只能把<T>當作Object使用，沒有發揮泛型的優勢。
當我們定義泛型類型<String>后，List<T>的泛型接口變為強類型List<String>：
// 無編譯器警告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 無強制轉型:
String first = list.get(0);
String second = list.get(1);
編譯器看到泛型類型List<String>就可以自動推斷出后面的ArrayList<T>的泛型類型必須是ArrayList<String>，因此，可以把代碼簡寫為：
// 可以省略后面的Number，編譯器可以自動推斷泛型類型：
List<String> list = new ArrayList<>();
3.1 泛型類
泛型類的語法形式：
class name<T1, T2, ..., Tn> { /* ... */ }
泛型類的聲明和非泛型類的聲明類似，除了在類名后面添加了類型參數聲明部分。由尖括號（<>）分隔的類型參數部分跟在類名后面。它指定類型參數（也稱為類型變量）T1，T2，...和 Tn。
一般將泛型中的類名稱為原型，而將 <> 指定的參數稱為類型參數。
在泛型出現之前，一個類要想處理所有類型的數據，只能使用Object做數據轉換。實例如下：
public class Info {
private Object value;
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}
使用泛型之后，其實就是將Object換成T，並聲明<T>：
public class Info<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
在上面的例子中，在初始化一個泛型類時，使用 <> 指定了內部具體類型，在編譯時就會根據這個類型做強類型檢查。
實際上，不使用 <> 指定內部具體類型，語法上也是支持的（不推薦這么做）,這樣的調用就失去泛型類型的優勢。如下所示：
public static void main(String[] args) {
Info info = new Info();
info.setValue(10);
System.out.println(info.getValue());
info.setValue("abc");
System.out.println(info.getValue());
}
上面是單個類型參數的泛型類。
下面我們看一下多個類型參數的泛型類該如何編寫。
例如，我們定義Pair不總是存儲兩個類型一樣的對象，就可以使用類型<T, K>：
public class Pair<T, K> {
private T first;
private K last;
public Pair(T first, K last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public K getLast() {
return last;
}
}
使用的時候，需要指出兩種類型：
Pair<String, Integer> p = new Pair<>("test", 123);
Java標准庫的Map<K, V>就是使用兩種泛型類型的例子。它對Key使用一種類型，對Value使用另一種類型。
小結
編寫泛型時，需要定義泛型類型<T>；
泛型可以同時定義多種類型，例如Map<K, V>。
3.2 泛型接口
接口也可以聲明泛型。
泛型接口語法形式：
public interface Content<T> {
T text();
}
泛型接口有兩種實現方式：
-
實現接口的子類明確聲明泛型類型
預先聲明繼承的具體類型的接口類，下面就是繼承的
Integer類型的接口類。public class IntContent implements Content<Integer> { private int text; public IntContent(int text) { this.text = text; } @Override public Integer text() { return text; } }因為子類並沒有泛型類型，所以正常使用就行。
InContent ic = new IntContent(10); -
實現接口的子類不明確聲明泛型類型
public class GenericsContent<T> implements Content<T> { private T text; public GenericsContent(T text) { this.text = text; } @Override public T text() { return text; } }此時子類也使用了泛型類型，就需要指定具體類型
Content<String> gc = new GenericsContent<>("ABC");
3.3 泛型方法
泛型方法是引入其自己的類型參數的方法。泛型方法可以是普通方法、靜態方法以及構造方法。
泛型方法語法形式如下：
public <T> T func(T obj) {}
注意：是否擁有泛型方法，與其所在的類是否是泛型沒有關系。
泛型方法的語法包括一個類型參數列表，在尖括號內，它出現在方法的返回類型之前。對於靜態泛型方法，類型參數部分必須出現在方法的返回類型之前。類型參數能被用來聲明返回值類型，並且能作為泛型方法得到的實際類型參數的占位符。
使用泛型方法的時候，通常不必指明類型參數，因為編譯器會為我們找出具體的類型。這稱為類型參數推斷（type argument inference）。類型推斷只對賦值操作有效，其他時候並不起作用。如果將一個泛型方法調用的結果作為參數，傳遞給另一個方法，這時編譯器並不會執行推斷。
編譯器會認為：調用泛型方法后，其返回值被賦給一個 Object 類型的變量。
public class GenericsMethodDemo01 {
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 GenericVarargsMethodDemo {
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]
4. 泛型的特性
4.1 類型擦除（Type Erasure）
Java 語言引入泛型是為了在編譯時提供更嚴格的類型檢查，並支持泛型編程。不同於 C++ 的模板機制，Java 泛型是使用類型擦除來實現的，使用泛型時，任何具體的類型信息都被擦除了。
那么，類型擦除做了什么呢？它做了以下工作：
- 把泛型中的所有類型參數替換為 Object，如果指定類型邊界，則使用類型邊界來替換。因此，生成的字節碼僅包含普通的類，接口和方法。
- 擦除出現的類型聲明，即去掉
<>的內容。比如T get()方法聲明就變成了Object get()；List<String>就變成了List。如有必要，插入類型轉換以保持類型安全。 - 生成橋接方法以保留擴展泛型類型中的多態性。類型擦除確保不為參數化類型創建新類；因此，泛型不會產生運行時開銷。
Java 泛型的實現方式不太優雅，但這是因為泛型是在 JDK5 時引入的，為了兼容老代碼，必須在設計上做一定的折中。
簡單來說類型擦除是指，虛擬機對泛型其實一無所知，所有的工作都是編譯器做的。
例如，我們編寫了一個泛型類Pair<T>，這是編譯器看到的代碼：
public class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
而虛擬機根本不知道泛型。這是虛擬機執行的代碼：
public class Pair {
private Object first;
private Object last;
public Pair(Object first, Object last) {
this.first = first;
this.last = last;
}
public Object getFirst() {
return first;
}
public Object getLast() {
return last;
}
}
因此，Java使用類型擦拭實現泛型，導致了：
- 編譯器把類型
<T>視為Object； - 編譯器根據
<T>實現安全的強制轉型。
因此，Java使用擦拭法實現泛型，導致了：
- 編譯器把類型
<T>視為Object； - 編譯器根據
<T>實現安全的強制轉型。
使用泛型的時候，我們編寫的代碼也是編譯器看到的代碼：
Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();
而虛擬機執行的代碼並沒有泛型：
Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();
所以，Java的泛型是由編譯器在編譯時實行的，編譯器內部永遠把所有類型T視為Object處理，但是，在需要轉型的時候，編譯器會根據T的類型自動為我們實行安全地強制轉型。
泛型的局限
了解了Java泛型的實現方式——類型擦除，我們就知道了Java泛型的局限：
局限一：<T>不能是基本類型，例如int，因為實際類型是Object，Object類型無法持有基本類型：
Pair<int> p = new Pair<>(1, 2); // compile error!
局限二：無法取得帶泛型的Class。觀察以下代碼：
public class test {
public static void main(String[] args) {
List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();
System.out.println(list1.getClass());
System.out.println(list2.getClass());
}
}
// Output:
// class java.util.ArrayList
// class java.util.ArrayList
因為T是Object，我們對ArrayList<Object>和ArrayList<String>類型獲取Class時，獲取到的是同一個Class，也就是ArrayList類的Class。
換句話說，所有泛型實例，無論T的類型是什么，getClass()返回同一個Class實例，因為編譯后它們全部都是ArrayList<Object>。
局限三：無法判斷帶泛型的類型：
List<Integer> p = new ArrayList<>();
// Compile error:
if (p instanceof List<String>) {
}
原因和前面一樣，並不存在List<String>.class，而是只有唯一的List.class。
泛型和繼承
正是由於泛型時基於類型擦除實現的，所以，泛型類型無法向上轉型。
向上轉型是指用子類實例去初始化父類，這是面向對象中多態的重要表現。
Integer 繼承了 Object；ArrayList 繼承了 List；但是 List<Interger> 卻並非繼承了 List<Object>。
這是因為，泛型類並沒有自己獨有的 Class 類對象。比如：並不存在 List<Object>.class 或是 List<Interger>.class，Java 編譯器會將二者都視為 List.class。
4.2 上邊界
在使用泛型的時候，我們還可以為傳入的泛型類型實參進行上下邊界的限制，如：類型實參只准傳入某種類型的父類或某種類型的子類。
extend通配符
為泛型添加上邊界，即傳入的類型實參必須是指定類型的子類型
// 可以限制傳入方法的參數的類型
<? extends xxx>
// 也可以限制T的類型
<T extends XXX>
// 類型邊界可以設置多個，語法形式如下：
<T extends B1 & B2 & B3>
注意：extends 關鍵字后面的第一個類型參數可以是類或接口，其他類型參數只能是接口。
<? extends xxx>
舉個例子：
public class test {
public static void main(String[] args) {
Pair<Integer> p = new Pair<>(123, 456);
int n = add(p);
System.out.println(n);
}
static int add(Pair<? extends Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}
class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
通過使用<? extends Number>，我們可以傳入Number類型的子類類型的數組。就可以執行數值類型的加法。
這種使用<? extends Number>的泛型定義稱之為上界通配符（Upper Bounds Wildcards），即把泛型類型T的上界限定在Number了。除了可以傳入Pair<Integer>類型，我們還可以傳入Pair<Double>類型，Pair<BigDecimal>類型等等，因為Double和BigDecimal都是Number的子類。
如果我們考察對Pair<? extends Number>類型調用getFirst()方法，實際的方法簽名變成了：
<? extends Number> getFirst();
接下來，我們再來考察一下Pair<T>的set方法：
public class test {
public static void main(String[] args) {
Pair<Integer> p = new Pair<>(123, 456);
int n = add(p);
System.out.println(n);
}
static int add(Pair<? extends Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
p.setFirst(new Integer(first.intValue() + 100));
p.setLast(new Integer(last.intValue() + 100));
return p.getFirst().intValue() + p.getFirst().intValue();
}
}
class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
public void setFirst(T first) {
this.first = first;
}
public void setLast(T last) {
this.last = last;
}
}
// 會得到一個編譯錯誤
// The method setFirst(capture#3-of ? extends Number) in the type Pair<capture#3-of ? extends Number> is not applicable for the arguments (int)Java(67108979)
編譯錯誤的原因在於，如果一開始我們傳入的p是Pair<Double>，顯然它滿足參數定義Pair<? extends Number>，然而，Pair<Double>的setFirst()顯然無法接受Integer類型。
這就是<? extends Number>通配符的一個重要限制：方法參數簽名setFirst(? extends Number)無法傳遞任何Number的子類型給setFirst(? extends Number)。
這里唯一的例外是可以給方法參數傳入null：
p.setFirst(null); // ok, 但是后面會拋出NullPointerException
p.getFirst().intValue(); // NullPointerException
使用extends限定T類型
在定義泛型類型Pair<T>的時候，也可以使用extends通配符來限定T的類型：
public class Pair<T extends Number> { ... }
現在，我們只能定義：
Pair<Number> p1 = null;
Pair<Integer> p2 = new Pair<>(1, 2);
Pair<Double> p3 = null;
因為Number、Integer和Double都符合<T extends Number>。
非Number類型將無法通過編譯：
Pair<String> p1 = null; // compile error!
Pair<Object> p2 = null; // compile error!
因為String、Object都不符合<T extends Number>，因為它們不是Number類型或Number的子類。
小結
使用類似<? extends Number>通配符作為方法參數時表示：
- 方法內部可以調用獲取
Number引用的方法，例如：Number n = obj.getFirst();； - 方法內部無法調用傳入
Number引用的方法（null除外），例如：obj.setFirst(Number n);。
即一句話總結：使用extends通配符表示可以讀，不能寫。
使用類似<T extends Number>定義泛型類時表示：
- 泛型類型限定為
Number以及Number的子類。
4.3 下邊界
super 下界通配符將未知類型限制為該類型的特定類型或超類類型。
和extends通配符相反，這次，我們希望接受Pair<Integer>類型，以及Pair<Number>、Pair<Object>，因為Number和Object是Integer的父類，setFirst(Number)和setFirst(Object)實際上允許接受Integer類型。
我們使用super通配符來改寫這個方法：
void set(Pair<? super Integer> p, Integer first, Integer last) {
p.setFirst(first);
p.setLast(last);
}
注意到Pair<? super Integer>表示，方法參數接受所有泛型類型為Integer或Integer父類的Pair類型。
這里注意到我們無法使用Integer類型來接收getFirst()的返回值，即下面的語句將無法通過編譯：
Integer x = p.getFirst();
因為如果傳入的實際類型是Pair<Number>，編譯器無法將Number類型轉型為Integer。
因此，使用<? super Integer>通配符表示：
- 允許調用
set(? super Integer)方法傳入Integer的引用； - 不允許調用
get()方法獲得Integer的引用。
唯一例外是可以獲取Object的引用：Object o = p.getFirst()。
換句話說，使用<? super Integer>通配符作為方法參數，表示方法內部代碼對於參數只能寫，不能讀。
對比extends和super通配符
我們再回顧一下extends通配符。作為方法參數，<? extends T>類型和<? super T>類型的區別在於：
<? extends T>允許調用讀方法T get()獲取T的引用，但不允許調用寫方法set(T)傳入T的引用（傳入null除外）；<? super T>允許調用寫方法set(T)傳入T的引用，但不允許調用讀方法T get()獲取T的引用（獲取Object除外）。
一個是允許讀不允許寫，另一個是允許寫不允許讀。
4.4 無限定通配符
我們已經討論了<? extends T>和<? super T>作為方法參數的作用。實際上，Java的泛型還允許使用無限定通配符（Unbounded Wildcard Type），即只定義一個?：
void sample(Pair<?> p) {
}
因為<?>通配符既沒有extends，也沒有super，因此：
- 不允許調用
set(T)方法並傳入引用（null除外）； - 不允許調用
T get()方法並獲取T引用（只能獲取Object引用）。
無界通配符有兩種應用場景：
- 可以使用 Object 類中提供的功能來實現的方法。
- 使用不依賴於類型參數的泛型類中的方法。
語法形式：<?>
public class GenericsUnboundedWildcardDemo {
public static void printList(List<?> list) {
for (Object elem : list) {
System.out.print(elem + " ");
}
System.out.println();
}
public static void main(String[] args) {
List<Integer> li = Arrays.asList(1, 2, 3);
List<String> ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);
}
}
// Output:
// 1 2 3
// one two three
小結
使用類似<? super Integer>通配符作為方法參數時表示：
- 方法內部可以調用傳入
Integer引用的方法，例如：obj.setFirst(Integer n);； - 方法內部無法調用獲取
Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。
即使用super通配符表示只能寫不能讀。
無限定通配符<?>很少使用，可以用<T>替換，同時它是所有<T>類型的超類。
4.5 泛型命名
泛型一些約定俗成的命名（實際並無意義，但是建議對應着來命名泛型）：
- E - Element
- K - Key
- N - Number
- T - Type
- V - Value
- S,U,V etc. - 2nd, 3rd, 4th types
5. end
理解泛型之后可以方便我們更好的閱讀Java框架的源碼，實際編程來說不一定會用到，但是可以用到泛型編程的地方，建議使用，可以簡化代碼。