前言

Java當中的泛型是JDK1.5版本中引入的一項技術，使用泛型可以使得我們的代碼更加安全，而且具備更好的可讀性，泛型大家都有所了解，可能覺得非常簡單，然而，泛型也有許許多多需要注意的細節，本文的主要目的就是將泛型的使用細節及注意事項一一歸納，

沒有泛型的程式

下面是一段沒有使用泛型的代碼示例：

package com.zwx.coreJava.genericity;

import java.util.ArrayList;
import java.util.List;

public class MyItem {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(1);
        list.add("中國");
        for (int i=0;i<list.size();i++){
             int a = (int)list.get(i);
             System.out.println(a);
        }
    }
}

顯然，上面這段代碼可以正常編譯，但是運行的時候就會報錯，這就是沒有泛型約束造成的后果，我們可以向list中添加任意資料型別，但是取值的時候就很容易出現型別轉換例外，所以為了使Java程式更加安全，泛型技術就應運而生了，

帶有泛型的程式

現在我么通過泛型將上面的程式進行改造一下：

List<Integer> list = new ArrayList<>();

因為改造之后的程式加入了泛型的約束，那么就限制了我們只能向list中添加Integer型別的資料，而如果添加其他型別，比如String型別(如下所示)，那么就會在編譯階段無法通過：

list.add("中國"); //編譯不通過

上面沒有添加泛型時，我們每次取出集合中的元素都需要進行型別強轉，而加了泛型，在取值的時候我們也不需要再手動去型別強轉，直接取出來(用約束的型別接收)就可以了，無需強轉，代碼又美觀又安全：

 int a = list.get(i);//無需強轉
 System.out.println(a);

PS：注意：8種基本資料型別不能作為泛型，泛型必須要使用其對應的包裝類

泛型的定義

上面通過一個簡單的對比示例展示了如何用泛型以及使用泛型的好處，而上面使用的泛型實際上是一種指定了具體型別的泛型，

直接指定具體泛型的方式是最簡單的，我們大部分場景下也都是使用具體型別的方式，但是泛型還有其他非具體型別的定義方式，接下來我們繼續介紹一下泛型的非具體型別定義方式，

泛型可以定義在類上，也可以定義在方法上，

定義泛型類

下面就是一個泛型類的定義方式：

package com.zwx.coreJava.genericity;

import java.util.Map;

public class GenericClass<K,V,M> {
    private M name;
    private Map<K,V> map;

    public V test(M m){
        return null;
    }
}

定義的泛型可以只有一個，也可以定義多個，一般使用大寫字母來作為泛型定義，不同的字母之前也沒有什么特殊含義，只不過一般默認的寫法都遵循以下默契：

• 1、E表示元素型別
• 2、K和V表示關鍵字與值的型別(比如map里面的key和value)
• 3、T則表示其他型別型別

PS:示例中我特意用了一個M來表示，就是想說明到呼叫什么字母來表示泛型，并沒有語法要求，

定義泛型類的時候需要注意的是，類上定義的泛型不能使用在靜態變數和靜態方法上，比如上面的方法改成靜態方法則會編譯不通過，原因我們后面再解釋，

需要注意的是，介面也算是一種特殊的類，所以這些規則也適用于介面，

定義泛型方法

如果我們不想在類上面定義泛型，只想在方法上定義泛型也可以，這就是泛型方法，泛型方法可以定義在泛型類里面，也可以定義在普通類里面，
泛型方法的定義需要把<>放在修飾符(如public static)之后，回傳值之前，
如下就是一個泛型的定義示例：

package com.zwx.coreJava.genericity;

public class GenericMethod {
    public <T> T test(T arg){
        System.out.println("generic method");
        return null;
    }
}

那么定義了泛型的方法應該如何呼叫呢？
我們把上面例子中的引數改為多引數看一下

package com.zwx.coreJava.genericity;

public class GenericMethod {
    public <T> T test(T...arg){
        System.out.println("generic method");
        return null;
    }

    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.test("1",1);
    }
}

上面這段代碼可以正常編譯輸出，并沒有起到限制的作用，所以如果非要限制，可以采用如下呼叫方式：

genericMethod.<String>test("1",1);

在方法前面加上泛型就可以起到限制作用，這時候代碼就會編譯不通過了，

泛型的繼承

上面的泛型定義實際上并沒有太多限制，還是可以傳入任意型別，那么假如我想限制一下泛型，比如說只能是某一個類的子類，又該如何定義呢？

如果想限定泛型為某一個類的子類，那么就需要用到extends關鍵字，注意：泛型的繼承只能使用extends，而不能使用implements(即使是介面也只能用extends關鍵字)，

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends Serializable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItem>();
    }
}

上面這個示例就會編譯不通過，因為我們的MyItem類并沒有實作Serializable介面，只有實作了Serializable介面的類才能被正常傳進去，

泛型的多繼承

在泛型里面支持多繼承，可以通過“&”或者“,”來實作，

我們先看一個&的例子：

package com.zwx.coreJava.genericity;

import java.io.Serializable;

public class GenericClass2<T extends MyItem & Serializable & Cloneable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub>();
    }
}

這里要求必須只能有一個類，而且如果有一個類，那么這個類必須放在第一位，如上面的例子，MyItem只能放在第一位，而下面這句話需要編譯通過，那么MyItemSub必須是如下定義：

public class MyItemSub extends MyItem implements Serializable,Cloneable {
}

也就是說必須同時滿足所有條件，

接下來再看一個逗號的例子：

package com.zwx.coreJava.genericity;

public class GenericClass2<T extends MyItem,Serializable,Cloneable>{
    public static void main(String[] args) {
        GenericClass2 genericClass2 = new GenericClass2<MyItemSub,MyItemSub,MyItemSub>();
    }
}

但是這種寫法似乎只對第一個限制型別有用，后面的限制并沒有用上，因為我除了第1個引數，后面2個引數我傳任意型別都可以編譯通過，

泛型的繼承規則

我們新建一個類繼承MyItem:

package com.zwx.coreJava.genericity;

public class MyItemSub extends MyItem {
}

這時候我們再去測驗一下這個例子：

package com.zwx.coreJava.genericity;

public class GenericClass3<T extends MyItem>{
    public static void main(String[] args) {
        MyItemSub myItemSub = new MyItemSub();
        MyItem myItem = myItemSub;//編譯通過

        GenericClass3<MyItemSub> myItemSubGenericClass = new GenericClass3<>();
        GenericClass3<MyItem> myItemGenericClass = myItemSubGenericClass;//編譯失敗
        
    }
}

可以看到最后這一句話編譯不通過，也就是說：GenericClass3<MyItem>和GenericClass3<MyItemSub>沒有任何關系（當然這個僅限于編譯階段），并不會因為泛型里面有繼承關系就影響到了外面的繼承關系，

泛型通配符

在某些時候，我們可以通過通配符“?”來作為泛型，?表示不限制型別，（下面例子中Manager類是Employee的子類，兩個類都是空類，就不貼代碼了）

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<?> list = new ArrayList<>();
        list.add(null);//編譯通過
        list.add(1);//報錯
}

可以看到，雖然?表示允許任意型別，但是和List<Object>還是有本質區別的，使用通配符作為泛型的不能直接設定元素，除了null值，
不過雖然不能直接設值，但是我們可以通過間接的方式設定值進去，

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<?> list = MyWildcard.init();
        Object obj = list.get(0);//通過
        list.add(new Employee());//不通過
    }

    public static List<?>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

雖然我不能直接設定值進去，但是我可以get獲得list的元素，這是因為設定的時候無法確認?到底是什么型別，所以Java會拒絕編譯，但是get元素的時候我可以直接賦值給Object，因為任何物件都是Object的子類，所以相當于知道了list內部物件的上界就是Object物件，用Object來接收不會有問題，

泛型通配符和extends關鍵字

通配符也可以使用extends關鍵字，

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<? extends Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//通過
        list.add(new Manager());//不通過

    public static List<? extends Employee>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

使用extends關鍵字和直接使用通配符區別不大，唯一的區別就是取值的時候我可以確定物件一定是Employee的子類，所以我可以直接使用Employee物件來接收，

換句話說就是:這種寫法我可以知道list內部元素的上界，但是我不知道你的下界，所以我只允許取值(用上界接收)，不允許設值(設值要用下界)

泛型通配符和super關鍵字

通配符還可以使用super關鍵字，限定型別為某個類的超類：

package com.zwx.coreJava.genericity.wildcard;

import java.util.ArrayList;
import java.util.List;

public class MyWildcard {
    public static void main(String[] args) {
        List<? super Employee> list = MyWildcard.init();
        Employee employee = list.get(0);//不通過
        Object obj = list.get(0);//編譯通過
        list.add(new Employee());//通過
    }

    public static List<? super Employee>  init(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee());
        return list;
    }
}

可以看到，這里就允許設值，因為super關鍵字限定了元素必須為Employee的父類，也就是我知道了元素的下限，所以我可以設值，但是取值因為不知道上界，所以只能用最頂層的Object，

T和?通配符的區別

這兩種表示方法有區別嗎？這兩個有本質的區別，總結一下主要有如下區別：

• 1、T表示的是形參，也就是說如果我們想要用T，那么必須要先定義才能用；而?通配符則表示的是實參，也就是說不需要定義，我就可以直接拿來使用，
• 2、T相當于是占位符，如果我們定義了T，而實際傳進去的是String，那么實際的約束型別就是String型別，而不是T；而?通配符可以理解為就是一種真實存在的特殊型別，
• 3、T可以使用多繼承，而?通配符不行，只能用單繼承
• 4、T不能使用super關鍵字，而?通配符可以使用super關鍵字，
• 5、?通配符表示的物件是存在繼承關系的，而T表示的不同泛型之間沒有任何關系,所以下面這個示例是成立的，

List<?> list = new ArrayList<>();
List<? extends Employee> list1 = new ArrayList<>();
list = list1;

泛型擦除

我們先看一個例子：

package com.zwx.coreJava.genericity.erasure;

import com.zwx.coreJava.genericity.wildcard.Employee;

import java.util.ArrayList;
import java.util.List;

public class TestErasure {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<?> list2 = new ArrayList<>();

        System.out.println(list.equals(list1));//true
        System.out.println(list.equals(list2));//true
    }
}

兩句話的輸出結果都是true，

這是因為Java中的泛型只是在編譯階段有效，而實際運行之后會擦除掉，相當于沒有泛型，上面的3個list都等價于List list，所以Java中的的泛型并不是真正的泛型，

所以讓我們回到上面的例子，為什么類泛型不能使用在靜態方法上？因為靜態方法不屬于某一個實體物件，而泛型在運行階段就被擦除了，那么靜態方法在加載的時候根本就無法知道這個泛型到底是什么型別，而非靜態方法是屬于實體物件，可以根據物件實體化狀態資訊得出泛型屬于什么型別，

泛型和陣列

Java官方明確說明，不能實體化一個明確引數型別的陣列，
請看下面一個例子(ArrElement是一個空類)：

package com.zwx.coreJava.genericity.array;

import java.util.ArrayList;
import java.util.List;

public class TestArray {
    public static void main(String[] args) {
        ArrElement<String>[] arr = new ArrElement<String>[10];//編譯不通過
        ArrElement<String>[] arr1 = new ArrElement[10];//編譯通過
        ArrElement<String>[] arr2 = (ArrElement<String>[])new ArrElement<?>[10];
    }
}

可以看到上面第1句話不允許編譯通過，而后面兩句話允許通過，這就是因為Java中禁止直接通過具體泛型來初始化一個陣列，但是孕育通過具體泛型來接收一個陣列，

那么Java中為什么要禁止通過實際型別來初始化陣列呢？
因為陣列在初始化之后就會記住資料的資料型別，但是泛型又能被擦出，這就會出現問題，
比如上面這個例子中第一句話，泛型被擦除后，實際代碼為：

ArrElement[] arr = new ArrElement[10];

那么這時候假如我執行以下兩句代碼：

Object[] objArr = arr;
objArr[0] = new ArrElement<Integer>();

這兩句話是完全可以通過陣列的安全性檢查的，但是這個元素型別和初始化的元素型別不一致，所以會導致型別錯誤，正是因為陣列會記住元素型別和泛型擦除導致了沖突，才禁止帶泛型初始化陣列，這樣陣列初始化的時候只會記住ArrElement物件,而不限定型別

總結

本文對Java泛型相關知識點進行了一個歸納整理，主要包括泛型類，泛型方法，多繼承，通配符和非通配符的區別，以及多繼承和陣列泛型相關知識點，

請關注我，和孤狼一起學習進步，