最近複習到泛型，才發現之前對泛型的瞭解僅僅停留在表面，在CSDN中也有很多大佬發的很好的文章，我在這也記錄一下我自己的學習過程，有錯誤請大家指出。本文參考Java泛型詳解 Java泛型詳解

什麼是泛型

在瞭解什麼是泛型之前，我們先觀察Java標準庫提供的ArrayList，他可以看作「可變長度」陣列。

實際上ArrayList內部就是一個Object[]陣列，配合儲存一個當前分配的長度，就可以充當「可變陣列」

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

如果上述ArrayList儲存String型別，會出現幾個缺點：
1、需要強制轉型
2、不方便，容易出錯

例如，程式碼必須這麼寫：

ArrayList list = new ArrayList();
list.add("Hello");
// 獲取到Object，必須強制轉型為String:
String first = (String) list.get(0);

很容易出現ClassCastException，因為容易「誤轉型」：

list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);

要解決上訴問題，我們可以給String單獨編寫一種ArrayList：

public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

這樣一來，存入的必須是String型別，取出的一定也是String型別。如果要儲存integer呢，也要為Integer單獨編寫一個ArrayList。對於其他的class也是一樣，我們都要為他們單獨編寫一個ArrayList，當然，這是不可能的，Java中的class有成百上千個。那這個要怎麼解決呢？

為了解決這個問題，我們必須把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，這樣我們就可以解決上訴問題了。

// 建立可以儲存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<型別>:

ArrayList<String> strList = new ArrayList<String>();

泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。

為什麼要用泛型

Java語言引入泛型的好處是安全簡單。可以將執行時錯誤提前到編譯時錯誤。

在Java SE 1.5之前，沒有泛型的情況的下，通過對型別Object的參照來實現引數的「任意化」，「任意化」帶來的缺點是要做顯式的強制型別轉換，而這種轉換是要求開發者對實際引數型別可以預知的情況下進行的。對於強制型別轉換錯誤的情況，編譯器可能不提示錯誤，在執行的時候才出現異常，這是一個安全隱患。泛型的好處是在編譯的時候檢查型別安全，並且所有的強制轉換都是自動和隱式的，提高程式碼的重用率

泛型的使用

泛型有三種使用方式，分別為：泛型介面、泛型類、泛型方法

泛型介面

除了ArrayList< T> 使用了泛型，還可以在介面中使用泛型。如：Arrays.sort(Object[])可以對任意陣列進行排序，但排序的元素必須實現Comparable< T>這個泛型介面：

public interface Comparable<T> {
    /**
     * 返回負數: 當前範例比引數o小
     * 返回0: 當前範例與引數o相等
     * 返回正數: 當前範例比引數o大
     */
    int compareTo(T o);
}

範例：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Person[] ps = new Person[] {
            new Person("Bob", 61),
            new Person("Alice", 88),
            new Person("Lily", 75),
        };
        Arrays.sort(ps);
        System.out.println(Arrays.toString(ps));
    }
}


class Person implements Comparable<Person> {
    String name;
    int score;
    Person(String name, int score) {
        this.name = name;
        this.score = score;
    }
    public int compareTo(Person other) {
        return this.name.compareTo(other.name);
    }
    public String toString() {
        return this.name + "," + this.score;
    }
}
//結果可以正確實現按name進行排序

泛型類

泛型型別用於類的定義中，被稱為泛型類。通過泛型可以完成對一組類的操作對外開放相同的介面。最典型的就是各種容器類，如：List、Set、Map。（這幾個是集合的知識，我到時也會貼出來）

那我們要怎麼編寫一個泛型類呢？編寫泛型類比普通類要複雜。通常來說，反省類一般用於集合類中。例如ArrayList< T > ，其實，我們平時很少需要編寫泛型類。

首先，按照某種型別，例如：String，來編寫類：

public class Test {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {
        return first;
    }
    public String getLast() {
        return last;
    }
}

然後將特定型別String替換為T，並申明< T >：

/*
此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的引數常用於表示泛型
在範例化泛型類時，必須指定T的具體型別
K ——鍵，比如對映的鍵。
V ——值，比如 List 和 Set 的內容，或者 Map 中的值。
E ——異常類。
T ——泛型。
*/
public class Test<T> {
    private T first;
    private T last;
    public Test(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

編寫泛型類時，要特別注意，泛型型別不能用於靜態方法。

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() { ... }
    public T getLast() { ... }

    // 對靜態方法使用<T>:
    public static Pair<T> create(T first, T last) {
        return new Pair<T>(first, last);
    }
}

對於靜態方法，我們可以單獨改寫為「泛型」方法，只需要使用另一個型別即可。對於上面的create()靜態方法，我們應該把它改為另一種泛型型別，例如，：

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() { ... }
    public T getLast() { ... }

    // 靜態泛型方法應該使用其他型別區分:
    public static <K> Pair<K> create(K first, K last) {
        return new Pair<K>(first, last);
    }
}

這樣才能清楚地將靜態方法的泛型型別和範例型別的泛型型別區分開

多個泛型型別

泛型還可以定義多種型別，例如，我們希望Test不總是儲存兩個型別一樣的物件，就可以使用型別<T, K>:

public class Test<T, K> {
    private T first;
    private K last;
    public Test(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

使用的時候，需要指出兩種型別：

Test<String, Integer> p = new Test<>("test", 123);

泛型方法

泛型方法使得該方法能獨立於類而產生變化。以下是一個基本的指導原則：無論何時，只要你能做到，你就應該儘量使用泛型方法。也就是說，如果使用泛型方法可以取代將整個類泛型化，那麼就應該只使用泛型方法，因為它可以使事情更清楚明白。另外，對於一個static的方法而言，無法存取泛型類的型別引數。所以，如果static方法需要使用泛型能力，就必須使其成為泛型方法。

要定義泛型方法，只需將泛型參數列置於返回值之前，就像下面這樣：

package Generics;
 
public class GenericMethods {
//當方法操作的參照資料型別不確定的時候，可以將泛型定義在方法上
	public <T> void f(T x){
		System.out.println(x.getClass().getName());
	}
	public static void main(String[] args) {
		GenericMethods gm = new GenericMethods();
		gm.f(99);
		gm.f("我是一個Java小白");
		gm.f(new Integer(99));
		gm.f(18.88);
		gm.f('a');
		gm.f(gm);
	}
}
/* 輸出結果：
java.lang.Integer
java.lang.String
java.lang.Integer
java.lang.Double
java.lang.Character
Generics.GenericMethods
 */

泛型的擦拭

泛型是一種類似」模板程式碼「的技術，不同語言的泛型實現方式不一定相同。Java語言的泛型實現方式是擦拭法（Type Erasure）。所謂擦拭法是指，虛擬機器器對泛型其實一無所知，所有的工作都是編譯器做的。

例如，我們編寫了一個泛型類Test< T >，這是編譯器看到的程式碼：

public class Test<T> {
    private T first;
    private T last;
    public Test(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

二虛擬機器器根本不知道泛型，這是虛擬機器器看到的：

public class Test{
    private Object first;
    private Object last;
    public Test(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用擦拭法實現泛型，導致了：

編譯器把型別視為Object；
編譯器根據實現安全的強制轉型。

瞭解了Java泛型的實現方式——擦拭法，我們就知道了Java泛型的侷限：

侷限一：< T>不能是基本型別，例如int，因為實際型別是Object，Object型別無法持有基本型別：

Test<int> p = new Test<>(1, 2); // compile error!

侷限二：無法取得帶泛型的Class。觀察以下程式碼：

public class Main {
    public static void main(String[] args) {
		Test<String> p1 = new Test<>("Hello", "world");
        Test<Integer> p2 = new Test<>(123, 456);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        System.out.println(c1==c2); // true
        System.out.println(c1==Test.class); // true
          }
}

class Test<T> {
    private T first;
    private T last;
    public Test(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

因為T是Object，我們對Test< String>和Test< Integer>型別獲取Class時，獲取到的是同一個Class，也就是Test類的Class。

換句話說，所有泛型範例，無論T的型別是什麼，getClass()返回同一個Class範例，因為編譯後它們全部都是Test< Object>。

侷限三：無法判斷帶泛型的型別：

Test<Integer> p = new Test<>(123, 456);
// Compile error:
if (p instanceof Test<String>) {
}

原因和前面一樣，並不存在Test< String>.class，而是隻有唯一的Test.class。

侷限四：不能範例化T型別：

public class Test<T> {
    private T first;
    private T last;
    public Test() {
        // Compile error:
        first = new T();
        last = new T();
    }
}

要範例化T型別，我們必須藉助額外的Class< T>引數：

public class Test<T> {
    private T first;
    private T last;
    public Test(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

泛型的繼承

一個類可以繼承自一個泛型類。例如：父類別的型別是Pair< Integer >，子類的型別時Intpair，可以這麼繼承：

public class IntPair extends Pair<Integer> {
}

使用的時候，因為子類Intpair並沒有泛型類，所以，正常使用即可：

IntPair ip = new IntPair(1, 2);

前面講了，我們無法獲取Pair的T型別，即給定一個變數Pair p，無法從p中獲取到T型別。

但是，在父類別是泛型型別的情況下，編譯器就必須把型別T（對IntPair來說，也就是Integer型別）儲存到子類的class檔案中，不然編譯器就不知道IntPair只能存取Integer這種型別。

在繼承了泛型型別的情況下，子類可以獲取父類別的泛型型別。例如：IntPair可以獲取到父類別的泛型型別Integer。獲取父類別的泛型型別程式碼比較複雜

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Main {
    public static void main(String[] args) {
    Class<IntPair> clazz = IntPair.class;
        Type t = clazz.getGenericSuperclass();
        if (t instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) t;
            Type[] types = pt.getActualTypeArguments(); // 可能有多個泛型型別
            Type firstType = types[0]; // 取第一個泛型型別
            Class<?> typeClass = (Class<?>) firstType;
            System.out.println(typeClass); // Integer
        }
	}
}

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;
    }
}

class IntPair extends Pair<Integer> {
    public IntPair(Integer first, Integer last) {
        super(first, last);
    }
}

extends和super萬用字元

我們在定義泛型類，泛型方法，泛型介面的時候經常會碰見很多不同的萬用字元，比如 T，E，K，V 等等，這些萬用字元又都是什麼意思呢？

常用的 T，E，K，V，？

本質上這些個都是萬用字元，沒啥區別，只不過是編碼時的一種約定俗成的東西。比如上述程式碼中的 T ，我們可以換成 A-Z 之間的任何一個字母都可以，並不會影響程式的正常執行，但是如果換成其他的字母代替 T ，在可讀性上可能會弱一些。通常情況下，T，E，K，V，？是這樣約定的：

T (type) 表示具體的一個java型別
K V (key value) 分別代表java鍵值中的Key Value
E (element) 代表Element
? 無限定萬用字元型別

<? extends T> 表示型別的上界（也叫子型別限定萬用字元），表示引數化型別的可能是T 或是 T的子類
<? super T> 表示型別下界（Java Core中叫超型別限定萬用字元），表示引數化型別是此型別的超型別（父類別型），直至Object

萬用字元使用場景

上限：？extends E：可以接收E型別或者E的子型別物件。

下限：？super E：可以接收E型別或者E的父類別型物件。

上限什麼時候用：往集合中新增元素時，既可以新增E型別物件，又可以新增E的子型別物件。為什麼？因為取的時候，E型別既可以接收E類物件，又可以接收E的子型別物件。

下限什麼時候用：當從集合中獲取元素進行操作的時候，可以用當前元素的型別接收，也可以用當前元素的父類別型接收。

萬用字元只有在修飾一個變數或引數的時候會用到，在定義泛型類或泛型方法的時候是不能使用萬用字元的。

為了更好的說明泛型萬用字元的使用，我們使用程式碼範例來加以說明。首先我們建立一個類 Test，是一個泛型類，裡面儲存一個變數 one

public class Test<T> {
    private T One;
    // 省略 get 和 set 方法
    // ......
}

我們再建立兩個類 Father 和 Son，Son 是 Father 的子類

// Father.java
public class Father {
}

// Son.java
public class Son extends Father{
}

如果我們按照小面的寫法，程式將會報錯：

public static void main(String[] args){
    Test<Father> a1 = new Test<Father>();
    Test<Son> a2 = new Test<Son>();
    test1(a1);
    test1(a2);  // 編譯錯誤
}

public void test1(Test<Father> a){...}

這是為什麼？因為雖然Son 是 Father 的子類，但 test1(Test a) 方法卻不能接收引數 a2，也就是說 Test 不是 Test 的子類。這個時候就可以使用萬用字元來解決，我們修改 test1 方法。

public static void main(String[] args){
    Test<Father> a1 = new Test<Father>();
    Test<Son> a2 = new Test<Son>();
    test1(a1);
    test1(a2);
}
public void test1(Test<? extends Father> a){...}

這樣可以可以正常呼叫，說明型別 A 是 A<? extends Father> 的子型別。

<? extends E> 萬用字元

用 extends 關鍵字宣告，表示引數化的型別可能是所指定的型別，或者是此型別的子類。

在型別引數中使用 extends 表示這個泛型中的引數必須是 E 或者 E 的子類，這樣有兩個好處：

如果傳入的型別不是 E 或者 E 的子類，編譯不成功
泛型中可以使用 E 的方法，要不然還得強轉成 E 才能使用

private <K extends A, E extends B> E test(K arg1, E arg2){
	E result = arg2;
	arg2.compareTo(arg1);
 //.....
   return
   result;
}

型別參數列中如果有多個型別引數上限，用逗號分開

使用extends萬用字元表示可以讀，不能寫。

< ? super E>萬用字元

用 super 進行宣告，表示引數化的型別可能是所指定的型別，或者是此型別的父類別型，直至 Object

在型別引數中使用 super 表示這個泛型中的引數必須是 E 或者 E 的父類別。

private<T> void test(List<? superT> dst, List<T> src){
for(T t : src) {
	dst.add(t);
    }
}
public static void main(String[] args) {    
List <Dog> dogs = new ArrayList<>();    
List <Animal> animals = new ArrayList<>();    
new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子類
class Dog extends Animal{}

?和T的區別

T 是一個 確定的 型別，通常用於泛型類和泛型方法的定義，？是一個 不確定 的型別，通常用於泛型方法的呼叫程式碼和形參，不能用於定義類和泛型方法。

區別1：通過 T 來確保泛型引數的一致性

// 通過 T 來 確保 泛型引數的一致性
public <T extends Number> void
test(List<T> dest, List<T> src)

//萬用字元是 不確定的，所以這個方法不能保證兩個 List 具有相同的元素型別
public void test(List<? extends Number> dest, List<? extends Number> src)

像下面的程式碼中，約定的 T 是 Number 的子類才可以，但是申明時是用的 String ，所以就會飄紅報錯。

不能保證兩個 List 具有相同的元素型別的情況

Test<String> test= new Test<>();
List<String> dest = new ArrayList<>();
List<Number> src = new ArrayList<>();
test.testNon(dest,src)

上面的程式碼在編譯器並不會報錯，但是當進入到 testNon 方法內部操作時（比如賦值），對於 dest 和 src 而言，就還是需要進行型別轉換

區別2：型別引數可以多重限定而萬用字元不行

public class Test implements A, B {
	/**
	*使用"&"符號設定多重邊界（Multi Bounds)，
	**/
	public static<T extends A & B> void test(T t){
	}
}

interface A{}
interface B{}

使用 & 符號設定多重邊界（Multi Bounds)，指定泛型型別 T 必須是 A和 B的共有子型別，此時變數 t 就具有了所有限定的方法和屬性。對於萬用字元來說，因為它不是一個確定的型別，所以不能進行多重限定

區別3：萬用字元可以使用超類限定而型別引數不行

型別引數 T 只具有一種型別限定方式：

T extends A

但是萬用字元 ? 可以進行兩種限定：

? extends A
? super A

Class< T > 和 Class< ? > 區別

最常見的是在反射場景下的使用，這裡以用一段發射的程式碼來說明下。

// 通過反射的方式生成  one
// 物件，這裡比較明顯的是，我們需要使用強制型別轉換
One one= (One)
Class.forName("com.glmapper.bridge.boot.generic.One").newInstance();

對於上述程式碼，在執行期，如果反射的型別不是 One類，那麼一定會報 java.lang.ClassCastException 錯誤。

對於這種情況，則可以使用下面的程式碼來代替，使得在在編譯期就能直接檢查到型別的問題：

public class Test2{
	public static <T> T creaeIntance(class<T> clazz) throws IllegalAccessException, InstantiationException{
		return clazz.newIntance();
	}
	
	public statci void main(String[] args) throws IllegalAccessException, InstantiationException {
		A a = creaeIntance(A.class);
		B b = creaeIntance(B.class);
	}
}

class A{}
class B{}

Class< T> 在範例化的時候，T 要替換成具體類。Class<?> 它是個通配泛型，? 可以代表任何型別，所以主要用於宣告時的限制情況。比如，我們可以這樣做申明：

// 可以
public Class<?> clazz;
// 不可以，因為 T 需要指定型別
public Class<T> clazzT;

所以當不知道定宣告什麼型別的 Class 的時候可以定義一個Class<?>。

public class Test2<T>{
	public class<?> clazz;

對比extends和super萬用字元

<? extends T>型別和<? super T>型別的區別在於：

<? extends T>允許呼叫讀方法T get()獲取T的參照，但不允許呼叫寫方法set(T)傳入T的參照（傳入null除外）

<? super T>允許呼叫寫方法set(T)傳入T的參照，但不允許呼叫讀方法T get()獲取T的參照（獲取Object除外）

一個是允許讀不允許寫，另一個是允許寫不允許讀。

我感覺個人的寫文章水平確實挺差勁的，自己大概懂得是咋回事，但是就是挺難表達出來的，所以對於泛型這篇文章，我寫了好久好久，也在網上看了很多大佬的文章，感覺他們都很厲害，讓我受益匪淺，我也是按照那些大佬的思路來寫的，雖然文章裡借鑑了許多大佬的成果，但是隻要把這些知識消化了，就是自己得了。這篇文章挺長的，雖然我有想分為兩部分發，但是我怕有些人並不會去看下一篇，而且在同一篇以後複習起來也比較容易點。

Java複習（八）----泛型詳解