Java基礎11：Java泛型詳解

這位大俠，這是我的公衆号：程式員江湖。

分享程式員面試與技術的那些事。幹貨滿滿，關注就送。

本文對java的泛型的概念和使用做了詳盡的介紹。

本文參考

https://blog.csdn.net/s10461/article/details/53941091 具體代碼在我的GitHub中可以找到

https://github.com/h2pl/MyTech

文章首發于我的個人部落格：

https://h2pl.github.io/2018/04/29/javase11

更多關于Java後端學習的内容請到我的CSDN部落格上檢視：

https://blog.csdn.net/a724888

泛型概述

泛型在java中有很重要的地位，在面向對象程式設計及各種設計模式中有非常廣泛的應用。

什麼是泛型？為什麼要使用泛型？

泛型，即“參數化類型”。一提到參數，最熟悉的就是定義方法時有形參，然後調用此方法時傳遞實參。那麼參數化類型怎麼了解呢？顧名思義，就是将類型由原來的具體的類型參數化，類似于方法中的變量參數，此時類型也定義成參數形式（可以稱之為類型形參），然後在使用/調用時傳入具體的類型（類型實參）。

泛型的本質是為了參數化類型（在不建立新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的資料類型被指定為一個參數，這種參數類型可以用在類、接口和方法中，分别被稱為泛型類、泛型接口、泛型方法。

一個栗子

一個被舉了無數次的例子：

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型測試","item = " + item);
}

毫無疑問，程式的運作結果會以崩潰結束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList可以存放任意類型，例子中添加了一個String類型，添加了一個Integer類型，再使用時都以String的方式使用，是以程式崩潰了。為了解決類似這樣的問題（在編譯階段就可以解決），泛型應運而生。

我們将第一行聲明初始化list的代碼更改一下，編譯器會在編譯階段就能夠幫我們發現類似這樣的問題。

List arrayList = new ArrayList();

…

//arrayList.add(100); 在編譯階段，編譯器就會報錯

特性

泛型隻在編譯階段有效。看下面的代碼：

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型測試","類型相同");
}

通過上面的例子可以證明，在編譯之後程式會采取去泛型化的措施。也就是說Java中的泛型，隻在編譯階段有效。在編譯過程中，正确檢驗泛型結果後，會将泛型的相關資訊擦出，并且在對象進入和離開方法的邊界處添加類型檢查和類型轉換的方法。也就是說，泛型資訊不會進入到運作時階段。

對此總結成一句話：泛型類型在邏輯上看以看成是多個不同的類型，實際上都是相同的基本類型。

泛型有三種使用方式，分别為：泛型類、泛型接口、泛型方法

泛型類

泛型類型用于類的定義中，被稱為泛型類。通過泛型可以完成對一組類的操作對外開放相同的接口。最典型的就是各種容器類，如：List、Set、Map。

泛型類的最基本寫法（這麼看可能會有點暈，會在下面的例子中詳解）：

class 類名稱 <泛型辨別：可以随便寫任意辨別号，辨別指定的泛型的類型>{
  private 泛型辨別 /*（成員變量類型）*/ var; 
  .....

  }

一個最普通的泛型類：

//此處T可以随便寫為任意辨別，常見的如T、E、K、V等形式的參數常用于表示泛型

//在執行個體化泛型類時，必須指定T的具體類型
public class Generic<T>{
    //在類中聲明的泛型整個類裡面都可以用，除了靜态部分，因為泛型是執行個體化時聲明的。
    //靜态區域的代碼在編譯時就已經确定，隻與類相關
    class A <E>{
        T t;
    }
    //類裡面的方法或類中再次聲明同名泛型是允許的，并且該泛型會覆寫掉父類的同名泛型T
    class B <T>{
        T t;
    }
    //靜态内部類也可以使用泛型，執行個體化時賦予泛型實際類型
    static class C <T> {
        T t;
    }
    public static void main(String[] args) {
        //報錯，不能使用T泛型，因為泛型T屬于執行個體不屬于類
//        T t = null;
    }

    //key這個成員變量的類型為T,T的類型由外部指定
    private T key;

    public Generic(T key) { //泛型構造方法形參key的類型也為T，T的類型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的傳回值類型為T，T的類型由外部指定
        return key;
    }
}

12-27 09:20:04.432 13063-13063/? D/泛型測試: key is 123456

12-27 09:20:04.432 13063-13063/? D/泛型測試: key is key_vlaue

定義的泛型類，就一定要傳入泛型類型實參麼？并不是這樣，在使用泛型的時候如果傳入泛型實參，則會根據傳入的泛型實參做相應的限制，此時泛型才會起到本應起到的限制作用。如果不傳入泛型類型實參的話，在泛型類中使用泛型的方法或成員變量定義的類型可以為任何的類型。

看一個例子：

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型測試","key is " + generic.getKey());
Log.d("泛型測試","key is " + generic1.getKey());
Log.d("泛型測試","key is " + generic2.getKey());
Log.d("泛型測試","key is " + generic3.getKey());

D/泛型測試: key is 111111
D/泛型測試: key is 4444
D/泛型測試: key is 55.55
D/泛型測試: key is false

注意：

泛型的類型參數隻能是類類型，不能是簡單類型。

不能對确切的泛型類型使用instanceof操作。如下面的操作是非法的，編譯時會出錯。

if(ex_num instanceof Generic){

}

泛型接口

泛型接口與泛型類的定義及使用基本相同。泛型接口常被用在各種類的生産器中，可以看一個例子：

//定義一個泛型接口
public interface Generator<T> {
    public T next();
}

當實作泛型接口的類，未傳入泛型實參時：

/**
 * 未傳入泛型實參時，與泛型類的定義相同，在聲明類的時候，需将泛型的聲明也一起加到類中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不聲明泛型，如：class FruitGenerator implements Generator<T>，編譯器會報錯："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

當實作泛型接口的類，傳入泛型實參時：

/**
 * 傳入泛型實參時：
 * 定義一個生産器實作這個接口,雖然我們隻建立了一個泛型接口Generator<T>
 * 但是我們可以為T傳入無數個實參，形成無數種類型的Generator接口。
 * 在實作類實作泛型接口時，如已将泛型類型傳入實參類型，則所有使用泛型的地方都要替換成傳入的實參類型
 * 即：Generator<T>，public T next();中的的T都要替換成傳入的String類型。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型通配符

我們知道Ingeter是Number的一個子類，同時在特性章節中我們也驗證過Generic與Generic實際上是相同的一種基本類型。那麼問題來了，在使用Generic作為形參的方法中，能否使用Generic的執行個體傳入呢？在邏輯上類似于Generic和Generic是否可以看成具有父子關系的泛型類型呢？

為了弄清楚這個問題，我們使用Generic這個泛型類繼續看下面的例子：

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);

// showKeyValue這個方法編譯器會為我們報錯：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);

通過提示資訊我們可以看到Generic不能被看作為`Generic的子類。由此可以看出:同一種泛型可以對應多個版本（因為參數類型是不确定的），不同版本的泛型類執行個體是不相容的。

回到上面的例子，如何解決上面的問題？總不能為了定義一個新的方法來處理Generic類型的類，這顯然與java中的多台理念相違背。是以我們需要一個在邏輯上可以表示同時是Generic和Generic父類的引用類型。由此類型通配符應運而生。

我們可以将上面的方法改一下：

public void showKeyValue1(Generic<?> obj){
    Log.d("泛型測試","key value is " + obj.getKey());

類型通配符一般是使用？代替具體的類型實參，注意，此處的？和Number、String、Integer一樣都是一種實際的類型，可以把？看成所有類型的父類。是一種真實的類型。

可以解決當具體類型不确定的時候，這個通配符就是 ? ；當操作類型時，不需要使用類型的具體功能時，隻使用Object類中的功能。那麼可以用 ? 通配符來表未知類型

public void showKeyValue(Generic obj){

System.out.println(obj);

}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

public void test () {
//        showKeyValue(gInteger);該方法會報錯
    showKeyValue1(gInteger);
}

public void showKeyValue1(Generic<?> obj) {
    System.out.println(obj);
}
// showKeyValue這個方法編譯器會為我們報錯：Generic<java.lang.Integer>
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);

。

泛型方法

在java中,泛型類的定義非常簡單，但是泛型方法就比較複雜了。

尤其是我們見到的大多數泛型類中的成員方法也都使用了泛型，有的甚至泛型類中也包含着泛型方法，這樣在初學者中非常容易将泛型方法了解錯了。

泛型類，是在執行個體化類的時候指明泛型的具體類型；泛型方法，是在調用方法的時候指明泛型的具體類型。

/**
 * 泛型方法的基本介紹
 * @param tClass 傳入的泛型實參
 * @return T 傳回值為T類型
 * 說明：
 *     1）public 與 傳回值中間<T>非常重要，可以了解為聲明此方法為泛型方法。
 *     2）隻有聲明了<T>的方法才是泛型方法，泛型類中的使用了泛型的成員方法并不是泛型方法。
 *     3）<T>表明該方法将使用泛型類型T，此時才可以在方法中使用泛型類型T。
 *     4）與泛型類的定義一樣，此處T可以随便寫為任意辨別，常見的如T、E、K、V等形式的參數常用于表示泛型。
 */
    public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
      IllegalAccessException{
            T instance = tClass.newInstance();
            return instance;
    }

Object obj = genericMethod(Class.forName("com.test.test"));

泛型方法的基本用法

光看上面的例子有的同學可能依然會非常迷糊，我們再通過一個例子，把我泛型方法再總結一下。

/** 
 * 這才是一個真正的泛型方法。
 * 首先在public與傳回值之間的<T>必不可少，這表明這是一個泛型方法，并且聲明了一個泛型T
 * 這個T可以出現在這個泛型方法的任意位置.
 * 泛型的數量也可以為任意多個 
 *    如：public <T,K> K showKeyName(Generic<T> container){
 *        ...
 *        }
 */

    public class 泛型方法 {
    @Test
    public void test() {
        test1();
        test2(new Integer(2));
        test3(new int[3],new Object());

        //列印結果
//        null
//        2
//        [I@3d8c7aca
//        java.lang.Object@5ebec15
    }
    //該方法使用泛型T
    public <T> void test1() {
        T t = null;
        System.out.println(t);
    }
    //該方法使用泛型T
    //并且參數和傳回值都是T類型
    public <T> T test2(T t) {
        System.out.println(t);
        return t;
    }

    //該方法使用泛型T,E
    //參數包括T,E
    public <T, E> void test3(T t, E e) {
        System.out.println(t);
        System.out.println(e);
    }
}

類中的泛型方法

當然這并不是泛型方法的全部，泛型方法可以出現雜任何地方和任何場景中使用。但是有一種情況是非常特殊的，當泛型方法出現在泛型類中時，我們再通過一個例子看一下

//注意泛型類先寫類名再寫泛型，泛型方法先寫泛型再寫方法名
//類中聲明的泛型在成員和方法中可用
class A <T, E>{
    {
        T t1 ;
    }
    A (T t){
        this.t = t;
    }
    T t;

    public void test1() {
        System.out.println(this.t);
    }

    public void test2(T t,E e) {
        System.out.println(t);
        System.out.println(e);
    }
}
@Test
public void run () {
    A <Integer,String > a = new A<>(1);
    a.test1();
    a.test2(2,"ds");
//        1
//        2
//        ds
}

static class B <T>{
    T t;
    public void go () {
        System.out.println(t);
    }
}

泛型方法與可變參數

再看一個泛型方法和可變參數的例子：

public class 泛型和可變參數 {
    @Test
    public void test () {
        printMsg("dasd",1,"dasd",2.0,false);
        print("dasdas","dasdas", "aa");
    }
    //普通可變參數隻能适配一種類型
    public void print(String ... args) {
        for(String t : args){
            System.out.println(t);
        }
    }
    //泛型的可變參數可以比對所有類型的參數。。有點無敵
    public <T> void printMsg( T... args){
        for(T t : args){
            System.out.println(t);
        }
    }
        //列印結果：
    //dasd
    //1
    //dasd
    //2.0
    //false

}

靜态方法與泛型

靜态方法有一種情況需要注意一下，那就是在類中的靜态方法使用泛型：靜态方法無法通路類上定義的泛型；如果靜态方法操作的引用資料類型不确定的時候，必須要将泛型定義在方法上。

即：如果靜态方法要使用泛型的話，必須将靜态方法也定義成泛型方法。

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在類中定義使用泛型的靜态方法，需要添加額外的泛型聲明（将這個方法定義成泛型方法）
     * 即使靜态方法要使用泛型類中已經聲明過的泛型也不可以。
     * 如：public static void show(T t){..},此時編譯器會提示錯誤資訊：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

泛型方法總結

泛型方法能使方法獨立于類而産生變化，以下是一個基本的指導原則：

無論何時，如果你能做到，你就該盡量使用泛型方法。也就是說，如果使用泛型方法将整個類泛型化，那麼就應該使用泛型方法。另外對于一個static的方法而已，無法通路泛型類型的參數。是以如果static方法要使用泛型能力，就必須使其成為泛型方法。

泛型上下邊界

在使用泛型的時候，我們還可以為傳入的泛型類型實參進行上下邊界的限制，如：類型實參隻準傳入某種類型的父類或某種類型的子類。

為泛型添加上邊界，即傳入的類型實參必須是指定類型的子類型

public class 泛型通配符與邊界 {
    public void showKeyValue(Generic<Number> obj){
        System.out.println("key value is " + obj.getKey());
    }
    @Test
    public void main() {
        Generic<Integer> gInteger = new Generic<Integer>(123);
        Generic<Number> gNumber = new Generic<Number>(456);
        showKeyValue(gNumber);
        //泛型中的子類也無法作為父類引用傳入
//        showKeyValue(gInteger);
    }
    //直接使用？通配符可以接受任何類型作為泛型傳入
    public void showKeyValueYeah(Generic<?> obj) {
        System.out.println(obj);
    }
    //隻能傳入number的子類或者number
    public void showKeyValue1(Generic<? extends Number> obj){
        System.out.println(obj);
    }

    //隻能傳入Integer的父類或者Integer
    public void showKeyValue2(Generic<? super Integer> obj){
        System.out.println(obj);
    }

    @Test
    public void testup () {
        //這一行代碼編譯器會提示錯誤，因為String類型并不是Number類型的子類
        //showKeyValue1(generic1);
        Generic<String> generic1 = new Generic<String>("11111");
        Generic<Integer> generic2 = new Generic<Integer>(2222);
        Generic<Float> generic3 = new Generic<Float>(2.4f);
        Generic<Double> generic4 = new Generic<Double>(2.56);

        showKeyValue1(generic2);
        showKeyValue1(generic3);
        showKeyValue1(generic4);
    }

    @Test
    public void testdown () {

        Generic<String> generic1 = new Generic<String>("11111");
        Generic<Integer> generic2 = new Generic<Integer>(2222);
        Generic<Number> generic3 = new Generic<Number>(2);
//        showKeyValue2(generic1);本行報錯，因為String并不是Integer的父類
        showKeyValue2(generic2);
        showKeyValue2(generic3);
    }
}

== 關于泛型數組要提一下 ==

看到了很多文章中都會提起泛型數組，經過檢視sun的說明文檔，在java中是”不能建立一個确切的泛型類型的數組”的。

也就是說下面的這個例子是不可以的：

List<String>[] ls = new ArrayList<String>[10];  

而使用通配符建立泛型數組是可以的，如下面這個例子：

List<?>[] ls = new ArrayList<?>[10];  

這樣也是可以的：

List<String>[] ls = new ArrayList[10];

下面使用Sun的一篇文檔的一個例子來說明這個問題：

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.

這種情況下，由于JVM泛型的擦除機制，在運作時JVM是不知道泛型資訊的，是以可以給oa[1]賦上一個ArrayList而不會出現異常，但是在取出資料的時候卻要做一次類型轉換，是以就會出現ClassCastException，如果可以進行泛型數組的聲明，上面說的這種情況在編譯期将不會出現任何的警告和錯誤，隻有在運作時才會出錯。

而對泛型數組的聲明進行限制，對于這樣的情況，可以在編譯期提示代碼有類型安全問題，比沒有任何提示要強很多。

下面采用通配符的方式是被允許的:數組的類型不可以是類型變量，除非是采用通配符的方式，因為對于通配符的方式，最後取出資料是要做顯式的類型轉換的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK

最後

本文中的例子主要是為了闡述泛型中的一些思想而簡單舉出的，并不一定有着實際的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其實，在實際的程式設計過程中，自己可以使用泛型去簡化開發，且能很好的保證代碼品質。

Java基礎11：Java泛型詳解

泛型概述

一個栗子

特性

泛型類

泛型接口

泛型通配符

泛型方法

泛型方法的基本用法

類中的泛型方法

泛型方法與可變參數

靜态方法與泛型

泛型方法總結

泛型上下邊界

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method