之前章節中我們多次提到過泛型這個概念，從本節開始，我們就來詳細討論Java中的泛型，雖然泛型的基本思維和概念是比較簡單的，但它有一些非常令人費解的語法、細節、以及局限性，內容比較多。
所以我們分為三節，逐步來討論，本節我們主要來介紹泛型的基本概念和原理，下節我們重點討論令人費解的通配符，最後一節，我們討論一些細節和泛型的局限性。
後續章節我們會介紹各種容器類，容器類可以說是日常程序開發中天天用到的，沒有容器類，難以想象能開發什麼真正有用的程序。而容器類是基於泛型的，不理解泛型，我們就難以深刻理解容器類。那，泛型到底是什麼呢？
什麼是泛型？
之前我們一直強調數據類型的概念，Java有8種基本類型，可以定義類，類相當於自定義數據類型，類之間還可以有組合和繼承。不過，在第19節，我們介紹了接口，其中提到，其實，很多時候，我們關心的不是類型，而是能力，針對接口和能力編程，不僅可以復用代碼，還可以降低耦合，提高靈活性。
泛型將接口的概念進一步延伸，"泛型"字面意思就是廣泛的類型，類、接口和方法代碼可以應用於非常廣泛的類型，代碼與它們能夠操作的數據類型不再綁定在一起，同一套代碼，可以用於多種數據類型，這樣，不僅可以復用代碼，降低耦合，同時，還可以提高代碼的可讀性和安全性。
這麼說可能比較抽象，接下來，我們通過一些例子逐步來說明。在Java中，類、接口、方法都可以是泛型的，我們先來看泛型類。
一個簡單泛型類
我們通過一個簡單的例子來說明泛型類的基本概念、實現原理和好處。
基本概念
我們直接來看代碼：
public class Pair<T> {
T first;
T second;
public Pair(T first, T second){
this.first = first;
this.second = second;
}
public T getFirst() {
return first;
}
public T getSecond() {
return second;
}
}
Pair就是一個泛型類，與普通類的區別，體現在：
T是什麼呢？T表示類型參數，泛型就是類型參數化，處理的數據類型不是固定的，而是可以作為參數傳入。
怎麼用這個泛型類，並傳遞類型參數呢？看代碼：
Pair<Integer> minmax = new Pair<Integer>(1,100); Integer min = minmax.getFirst(); Integer max = minmax.getSecond();
Pair<Integer>，這裡Integer就是傳遞的實際類型參數。
Pair類的代碼和它處理的數據類型不是綁定的，具體類型可以變化。上面是Integer，也可以是String，比如：
Pair<String> kv = new Pair<String>("name","老馬");
類型參數可以有多個，Pair類中的first和second可以是不同的類型，多個類型之間以逗號分隔，來看改進後的Pair類定義：
public class Pair<U, V> {
U first;
V second;
public Pair(U first, V second){
this.first = first;
this.second = second;
}
public U getFirst() {
return first;
}
public V getSecond() {
return second;
}
}
可以這樣使用：
Pair<String,Integer> pair = new Pair<String,Integer>("老馬",100);
<String,Integer>既出現在了聲明變量時，也出現在了new後面，比較啰嗦，Java支持省略後面的類型參數，可以這樣：
Pair<String,Integer> pair = new Pair<>("老馬",100);
基本原理
泛型類型參數到底是什麼呢？為什麼一定要定義類型參數呢？定義普通類，直接使用Object不就行了嗎？比如，Pair類可以寫為：
public class Pair {
Object first;
Object second;
public Pair(Object first, Object second){
this.first = first;
this.second = second;
}
public Object getFirst() {
return first;
}
public Object getSecond() {
return second;
}
}
使用Pair的代碼可以為：
Pair minmax = new Pair(1,100);
Integer min = (Integer)minmax.getFirst();
Integer max = (Integer)minmax.getSecond();
Pair kv = new Pair("name","老馬");
String key = (String)kv.getFirst();
String value = (String)kv.getSecond();
這樣是可以的。實際上，Java泛型的內部原理就是這樣的。
我們知道，Java有Java編譯器和Java虛擬機，編譯器將Java源代碼轉換為.class文件，虛擬機加載並運行.class文件。對於泛型類，Java編譯器會將泛型代碼轉換為普通的非泛型代碼，就像上面的普通Pair類代碼及其使用代碼一樣，將類型參數T擦除，替換為Object，插入必要的強制類型轉換。Java虛擬機實際執行的時候，它是不知道泛型這回事的，它只知道普通的類及代碼。
再強調一下，Java泛型是通過擦除實現的，類定義中的類型參數如T會被替換為Object，在程序運行過程中，不知道泛型的實際類型參數，比如Pair<Integer>，運行中只知道Pair，而不知道Integer，認識到這一點是非常重要的，它有助於我們理解Java泛型的很多限制。
Java為什麼要這麼設計呢？泛型是Java 1.5以後才支持的，這麼設計是為了兼容性而不得已的一個選擇。
泛型的好處
既然只使用普通類和Object就是可以的，而且泛型最後也轉換為了普通類，那為什麼還要用泛型呢？或者說，泛型到底有什麼好處呢？
主要有兩個好處：
語言和程序設計的一個重要目標是將bug盡量消滅在搖籃裡，能消滅在寫代碼的時候，就不要等到代碼寫完，程序運行的時候。
只使用Object，代碼寫錯的時候，開發環境和編譯器不能幫我們發現問題，看代碼：
Pair pair = new Pair("老馬",1);
Integer id = (Integer)pair.getFirst();
String name = (String)pair.getSecond();
看出問題了嗎？寫代碼時，不小心，類型弄錯了，不過，代碼編譯時是沒有任何問題的，但，運行時，程序拋出了類型轉換異常ClassCastException。
如果使用泛型，則不可能犯這個錯誤，如果這麼寫代碼：
Pair<String,Integer> pair = new Pair<>("老馬",1);
Integer id = pair.getFirst();
String name = pair.getSecond();
開發環境如Eclipse會提示你類型錯誤，即使沒有好的開發環境，編譯時，Java編譯器也會提示你。這稱之為類型安全，也就是說，通過使用泛型，開發環境和編譯器能確保你不會用錯類型，為你的程序多設置一道安全防護網。
使用泛型，還可以省去繁瑣的強制類型轉換，再加上明確的類型信息，代碼可讀性也會更好。
容器類
泛型類最常見的用途是作為容器類，所謂容器類，簡單的說，就是容納並管理多項數據的類。數組就是用來管理多項數據的，但數組有很多限制，比如說，長度固定，插入、刪除操作效率比較低。計算機技術有一門課程叫數據結構，專門討論管理數據的各種方式。
這些數據結構在Java中的實現主要就是Java中的各種容器類，甚至，Java泛型的引入主要也是為了更好的支持Java容器。後續章節我們會詳細討論主要的Java容器，本節我們先自己實現一個非常簡單的Java容器，來解釋泛型的一些概念。
我們來實現一個簡單的動態數組容器，所謂動態數組，就是長度可變的數組，底層數組的長度當然是不可變的，但我們提供一個類，對這個類的使用者而言，好像就是一個長度可變的數組，Java容器中有一個對應的類ArrayList，本節我們來實現一個簡化版。
來看代碼：
public class DynamicArray<E> {
private static final int DEFAULT_CAPACITY = 10;
private int size;
private Object[] elementData;
public DynamicArray() {
this.elementData = new Object[DEFAULT_CAPACITY];
}
private void ensureCapacity(int minCapacity) {
int oldCapacity = elementData.length;
if(oldCapacity>=minCapacity){
return;
}
int newCapacity = oldCapacity * 2;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
public void add(E e) {
ensureCapacity(size + 1);
elementData[size++] = e;
}
public E get(int index) {
return (E)elementData[index];
}
public int size() {
return size;
}
public E set(int index, E element) {
E oldValue = get(index);
elementData[index] = element;
return oldValue;
}
}
DynamicArray就是一個動態數組，內部代碼與我們之前分析過的StringBuilder類似，通過ensureCapacity方法來根據需要擴展數組。作為一個容器類，它容納的數據類型是作為參數傳遞過來的，比如說，存放Double類型：
DynamicArray<Double> arr = new DynamicArray<Double>();
Random rnd = new Random();
int size = 1+rnd.nextInt(100);
for(int i=0; i<size; i++){
arr.add(Math.random());
}
Double d = arr.get(rnd.nextInt(size));
這就是一個簡單的容器類，適用於各種數據類型，且類型安全。本節後面和後面兩節還會以DynamicArray為例進行擴展，以解釋泛型概念。
具體的類型還可以是一個泛型類，比如，可以這樣寫：
DynamicArray<Pair<Integer,String>> arr = new DynamicArray<>()
arr表示一個動態數組，每個元素是Pair<Integer,String>類型。
泛型方法
除了泛型類，方法也可以是泛型的，而且，一個方法是不是泛型的，與它所在的類是不是泛型沒有什麼關系。
我們看個例子：
public static <T> int indexOf(T[] arr, T elm){
for(int i=0; i<arr.length; i++){
if(arr[i].equals(elm)){
return i;
}
}
return -1;
}
這個方法就是一個泛型方法，類型參數為T，放在返回值前面，它可以這麼調用：
indexOf(new Integer[]{1,3,5}, 10)
也可以這麼調用：
indexOf(new String[]{"hello","老馬","編程"}, "老馬")
indexOf表示一個算法，在給定數組中尋找某一個元素，這個算法的基本過程與具體數據類型沒有什麼關系，通過泛型，它就可以方便的應用於各種數據類型，且編譯器保證類型安全。
與泛型類一樣，類型參數可以有多個，多個以逗號分隔，比如：
public static <U,V> Pair<U,V> makePair(U first, V second){
Pair<U,V> pair = new Pair<>(first, second);
return pair;
}
與泛型類不同，調用方法時一般並不需要特意指定類型參數的實際類型是什麼，比如調用makePair：
makePair(1,"老馬");
並不需要告訴編譯器U的類型是Integer，V的類型是String，Java編譯器可以自動推斷出來。
泛型接口
接口也可以是泛型的，我們之前介紹過的Comparable和Comparator接口都是泛型的，它們的代碼如下：
public interface Comparable<T> {
public int compareTo(T o);
}
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
與前面一樣，T是類型參數。實現接口時，應該指定具體的類型，比如，對Integer類，實現代碼是：
public final class Integer extends Number implements Comparable<Integer>{
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
//...
}
通過implements Comparable<Integer>，Integer實現了Comparable接口，指定了實際類型參數為Integer，表示Integer只能與Integer對象進行比較。
再看Comparator的一個例子，String類內部一個Comparator的接口實現為：
private static class CaseInsensitiveComparator
implements Comparator<String> {
public int compare(String s1, String s2) {
//....
}
}
這裡，指定了實際類型參數為String。
類型參數的限定
在之前的介紹中，無論是泛型類、泛型方法還是泛型接口，關於類型參數，我們都知之甚少，只能把它當做Object，但Java支持限定這個參數的一個上界，也就是說，參數必須為給定的上界類型或其子類型，這個限定是通過extends這個關鍵字來表示的。
這個上界可以是某個具體的類，或者某個具體的接口，也可以是其他的類型參數，我們逐個來看下其應用。
上界為某個具體類
比如說，上面的Pair類，可以定義一個子類NumberPair，限定兩個類型參數必須為Number，代碼如下：
public class NumberPair<U extends Number, V extends Number> extends Pair<U, V> {
public NumberPair(U first, V second) {
super(first, second);
}
}
限定類型後，就可以使用該類型的方法了，比如說，對於NumberPair類，first和second變量就可以當做Number進行處理了，比如可以定義一個求和方法，如下所示：
public double sum(){
return getFirst().doubleValue()
+getSecond().doubleValue();
}
可以這麼用：
NumberPair<Integer, Double> pair = new NumberPair<>(10, 12.34); double sum = pair.sum();
限定類型後，如果類型使用錯誤，編譯器會提示。
指定邊界後，類型擦除時就不會轉換為Object了，而是會轉換為它的邊界類型，這也是容易理解的。
上界為某個接口
在泛型方法中，一種常見的場景是限定類型必須實現Comparable接口，我們來看代碼：
public static <T extends Comparable> T max(T[] arr){
T max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i].compareTo(max)>0){
max = arr[i];
}
}
return max;
}
max方法計算一個泛型數組中的最大值，計算最大值需要進行元素之間的比較，要求元素實現Comparable接口，所以給類型參數設置了一個上邊界Comparable，T必須實現Comparable接口。
不過，直接這麼寫代碼，Java中會給一個警告信息，因為Comparable是一個泛型接口，它也需要一個類型參數，所以完整的方法聲明應該是：
public static <T extends Comparable<T>> T max(T[] arr){
//...
}
<T extends Comparable<T>>是一種令人費解的語法形式，這種形式稱之為遞歸類型限制，可以這麼解讀，T表示一種數據類型，必須實現Comparable接口，且必須可以與相同類型的元素進行比較。
上界為其他類型參數
上面的限定都是指定了一個明確的類或接口，Java支持一個類型參數以另一個類型參數作為上界。為什麼需要這個呢？
我們看個例子，給上面的DynamicArray類增加一個實例方法addAll，這個方法將參數容器中的所有元素都添加到當前容器裡來，直覺上，代碼可以這麼寫：
public void addAll(DynamicArray<E> c) {
for(int i=0; i<c.size; i++){
add(c.get(i));
}
}
但這麼寫有一些局限性，我們看使用它的代碼：
DynamicArray<Number> numbers = new DynamicArray<>(); DynamicArray<Integer> ints = new DynamicArray<>(); ints.add(100); ints.add(34); numbers.addAll(ints);
numbers是一個Number類型的容器，ints是一個Integer類型的容器，我們希望將ints添加到numbers中，因為Integer是Number的子類，應該說，這是一個合理的需求和操作。
但，Java會在number.addAll(ints)這行代碼上提示編譯錯誤，提示，addAll需要的參數類型為DynamicArray<Number>，而傳遞過來的參數類型為DynamicArray<Integer>，不適用，Integer是Number的子類，怎麼會不適用呢？
事實就是這樣，確實不適用，而且是很有道理的，假設適用，我們看下會發生什麼。
DynamicArray<Integer> ints = new DynamicArray<>(); //假設下面這行是合法的 DynamicArray<Number> numbers = ints; numbers.add(new Double(12.34));
那最後一行就是合法的，這時，DynamicArray<Integer>中就會出現Double類型的值，而這，顯然就破壞了Java泛型關於類型安全的保證。
我們強調一下，雖然Integer是Number的子類，但DynamicArray<Integer>並不是DynamicArray<Number>的子類，DynamicArray<Integer>的對象也不能賦值給DynamicArray<Number>的變量，這一點初看上去是違反直覺的，但這是事實，必須要理解這一點。
不過，我們的需求是合理的啊，將Integer添加到Number容器中，這沒有問題啊。這個問題，可以通過類型限定，這樣來解決：
public <T extends E> void addAll(DynamicArray<T> c) {
for(int i=0; i<c.size; i++){
add(c.get(i));
}
}
E是DynamicArray的類型參數，T是addAll的類型參數，T的上界限定為E，這樣，下面的代碼就沒有問題了：
DynamicArray<Number> numbers = new DynamicArray<>(); DynamicArray<Integer> ints = new DynamicArray<>(); ints.add(100); ints.add(34); numbers.addAll(ints);
對於這個例子，這個寫法有點啰嗦，下節我們會看到一種簡化的方式。
小結
泛型是計算機程序中一種重要的思維方式，它將數據結構和算法與數據類型相分離，使得同一套數據結構和算法，能夠應用於各種數據類型，而且還可以保證類型安全，提高可讀性。在Java中，泛型廣泛應用於各種容器類中，理解泛型是深刻理解容器的基礎。
本節介紹了泛型的基本概念，包括泛型類、泛型方法和泛型接口，關於類型參數，我們介紹了多種上界限定，限定為某具體類、某具體接口、或其他類型參數。泛型類最常見的用途是容器類，我們實現了一個簡單的容器類DynamicArray，以解釋泛型概念。
在Java中，泛型是通過類型擦除來實現的，它是Java編譯器的概念，Java虛擬機運行時對泛型基本一無所知，理解這一點是很重要的，它有助於我們理解Java泛型的很多局限性。
關於泛型，Java中有一個通配符的概念，語法非常令人費解，而且容易混淆，下一節，我們力圖對它進行清晰的剖析。
----------------
未完待續，查看最新文章，敬請關注微信公眾號“老馬說編程”(掃描下方二維碼)，從入門到高級，深入淺出，老馬和你一起探索Java編程及計算機技術的本質。用心寫作，原創文章，保留所有版權。
