最近復習到泛型，才發現之前對泛型的了解僅僅停留在表面，在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除外）

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

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/179998.html

標籤：其他

上一篇：Spring Boot:application/x-www-form-urlencoded；charset=UTF-8‘ not supported

下一篇：我的IDEA常用快捷鍵記錄

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