泛型，有點難度，會讓很多人懵逼，那是因為你沒有看這篇文章！

本文轉載自查看原文 2020-01-17 09:31 1972 java/ java技術/ 泛型

本文主要講解泛型類型的解析，泛型算是必須要掌握的一塊硬核知識，在很多地方都會用到，這塊如果理解了，在閱讀其他框架源碼的時候會讓你更容易一些，看完本文之后大家對泛型也有一個新的認識。

關於泛型的解析上面，我們需要先了解一些類和接口，這些比較關鍵，這些都位於java.lang.reflect包中，類圖如下：

下面一個個來解釋。

Type接口

這是一個頂層接口，java中的任何類型都可以用這個來表示，這個接口是Java編程語言中所有類型的公共超接口。這些類型包括原始類型、泛型類型、泛型變量類型、通配符類型、泛型數組類型、數組類型等各種類型。

這個接口代碼比較簡單，源碼：

public interface Type {
    /**
     * Returns a string describing this type, including information
     * about any type parameters.
     *
     * @implSpec The default implementation calls {@code toString}.
     *
     * @return a string describing this type
     * @since 1.8
     */
    default String getTypeName() {
        return toString();
    }
}

這個接口只有一個方法getTypeName，用於返回具體類型的名稱，是一個默認方法，默認會調用當前類的toString方法，實現類也可以對這個方法重寫。

GenericDeclaration接口

所有聲明泛型變量的公共接口，這個接口中定義了一個方法：

public TypeVariable<?>[] getTypeParameters()

這個方法用於獲取聲明的泛型變量類型清單。

泛型變量可以在類和方法中進行聲明，從上面類圖中也可以看出來，java中任何類可以使用Class對象表示，方法可以用Method類表示，類圖中可以知，Class類和Method類實現了GenericDeclaration接口，所以可以調用他們的getTypeParameters方法獲取其聲明的泛型參數列表。

類中定義泛型變量類型

public class Demo1<T1, T2 extends Integer, T3 extends Demo1I1 & Demo1I2>

上面代碼表示Demo1這個類中聲明了3個泛型變量類型：T1、T2、T3，所以如果去調用這個類的Clas對象中的getTypeParameters方法可以獲取到這三個泛型變量的信息，文章后面有案例演示。

方法中定義泛型變量類型

public <T1, T2 extends Integer, T3 extends Demo2I1 & Demo2I2> T3 m1(T1 t1, T2 t2, T3 t3, String s) {
    return t3;
}

上面m1方法中聲明了三個泛型類型變量：T1、T2、T3；java中可以方法的任何信息都可以通過Method對象來獲取，Mehod類實現了GenericDeclaration接口，所以Method類中實現了GenericDeclaration接口中的getTypeParameters方法，調用這個方法就可以獲取m1方法中3個泛型變量類型的信息，文章后面有案例演示。

Class類

這個比較常見，Class類的對象表示JVM中一個類或者接口，每個java對象被加載到jvm中都會表現為一個Class類型的對象，java中的數組也被映射為Class對象，所有元素類型相同且維數相同的數組都共享一個class對象，通過Class對象可以獲取類或者接口中的任何信息，比如：類名、類中聲明的泛型信息、類的修飾符、類的父類信息、類的接口信息、類中的任何方法信息、類中任何字段信息等等。

Class對象獲取方式

在程序中我們可以通過3中方式獲取Class對象：

1.類名.class
2.對象.getClass()
3.Class.forName("類或者接口的完整名稱")

常用的方法

Field[] getFields()

這個方法會返回當前類的以及其所有父類、父類的父類中所有public類型的字段。

Field[] getDeclaredFields()

這個方法會返回當前類中所有字段（和修飾符無關），也就說不管這個字段是public還是private或者是protected，都會返回，有一點需要注意，只返回自己內部定義的字段，不包含其父類中的，這點需要注意，和getFields是有區別的。

Method[] getMethods()

這個方法會返回當前類的以及其所有父類的、父類的父類的、自己實現的接口、父接口繼承的接口中的所有public類型的方法，需要注意一下，接口中的方法默認都是public類型的，接口中的方法public修飾符是可以省略的。

Method[] getDeclaredMethods()

返回當前類中定義的所有方法，不管這個方法修飾符是什么類型的，注意只包含自己內部定義的方法，不包含當前類的父類或者其實現的接口中定義的。

Type getGenericSuperclass()

返回父類的類型信息，如果父類是泛型類型，會返回超類中泛型的詳細信息，這個方法比較關鍵，后面會有詳細案例。

TypeVariable<Class<T>>[] getTypeParameters()

Class類繼承了java.lang.reflect.GenericDeclaration接口，上面這個方法是在GenericDeclaration接口中定義的，Class類中實現了這個接口，用於返回當前類中聲明的泛型變量參數列表。

Method類

這個類用來表示java中的任何一個方法，通過這個類可以獲取java中方法的任何信息，比如：方法的修飾符、方法名稱、方法的參數、方法返回值、方法中聲明的泛型參數列表等方法的一切信息。

常用的方法

String getName()

用來獲取方法的名稱。

Type[] getGenericParameterTypes()

返回方法的參數信息，如果參數是泛型類型的，會返回泛型的詳細信息，這個方法后面會演示。

Type getGenericReturnType()

返回方法的返回值類型，如果返回值是泛型的，會包含泛型的詳細信息。

TypeVariable<Method>[] getTypeParameters()

Method類繼承了java.lang.reflect.GenericDeclaration接口，上面這個方法是在GenericDeclaration接口中定義的，Method類中實現了這個接口，用於返回當前方法中聲明的泛型變量參數列表。

Field類

這個類用來表示java中的字段，通過這個類可以獲取java中字段的任何信息，比如：字段的修飾符、字段名稱、字段類型、泛型字段的類型等字段的一切信息。

常用的方法

String getName()

獲取字段的名稱。

Class<?> getType()

獲取字段類型所屬的Class對象。

Type getGenericType()

獲取字段的類型，如果字段是泛型類型的，會返回泛型類型的詳細信息；如果字段不是泛型類型的，和getType返回的結果是一樣的。

Class<?> getDeclaringClass()

獲取這個字段是在哪個類中聲明的，也就是當前字段所屬的類。

ParameterizedType接口

這個接口表示參數化類型，例如List<String>、Map<Integer,String>、UserMapper<UserModel>這種帶有泛型的類型。

常用方法

這個接口中定義了3個方法，都比較重要，來看一下。

Type[] getActualTypeArguments()

獲取泛型類型中的類型列表，就是<>中包含的參數列表，如：List<String>泛型類型列表只有一個是String，而Map<Integer,String>泛型類型中包含2個類型：Integer和String，UserMapper<UserModel>泛型類型為UserModel，實際上就是<和>中間包含的類型列表。

Type getRawType()

返回參數化類型中的原始類型，比如：List<String>的原始類型為List，UserMapper<UserModel>原始類型為UserMapper，也就是<符號前面的部分。

Type[] getOwnerType()

返回當前類型所屬的類型。例如存在A<T>類，其中定義了內部類InnerA<I>，則InnerA<I>所屬的類型為A<I>，如果是頂層類型則返回null。這種關系比較常見的示例是Map<K,V>接口與Map.Entry<K,V>接口，Map<K,V>接口是Map.Entry<K,V>接口的所有者。

TypeVariable接口

這個接口表示的是泛型變量，例如：List<T>中的T就是類型變量；而class C1<T1,T2,T3>{}表示一個類，這個類中定義了3個泛型變量類型，分別是T1、T2和T2，泛型變量在java中使用TypeVariable接口來表示，可以通過這個接口提供的方法獲取泛型變量類型的詳細信息。

常用的方法

Type[] getBounds()

獲取泛型變量類型的上邊界，如果未明確什么上邊界默認為Object。例如：class Test<K extend Person>中K的上邊界只有一個，是Person；而class Test<T extend List & Iterable>中T的上邊界有2個，是List和Iterable

D getGenericDeclaration()

獲取聲明該泛型變量的原始類型，例如：class Test<K extend Person>中的K為泛型變量，這個泛型變量時Test類定義的時候聲明的，說明如果調用getGenericDeclaration方法返回的就是Test對應的Class對象。

還有方法中也可以定義泛型類型的變量，如果在方法中定義，那么上面這個方法返回的就是定義泛型變量的方法了，返回的就是Method對象。

String getName()

獲取在源碼中定義時的名字，如：class Test<K extend Person>就是K；class Test1<T>中就是T。

WildcardType接口

表示的是通配符泛型，通配符使用問號表示，例如：? extends Number和? super Integer。

常用方法

接口中定義了2個方法。

Type[] getUpperBounds()

返回泛型變量的上邊界列表。

Type[] getLowerBounds()

返回泛型變量的下邊界列表。

GenericArrayType接口

表示的是數組類型，且數組中的元素是ParameterizedType或者TypeVariable。

例如：List<String>[]或者T[]。

常用方法

這個接口只有一個方法：

Type getGenericComponentType()

這個方法返回數組的組成元素。

上面的大家多看幾遍，下面開始上案例，加深對上面的理解和應用，信息量會比較大，慢慢理解。

泛型變量

泛型變量可以在類中和方法中定義。

泛型變量類型的使用TypeVariable接口來表示，所以可以通過TypeVariable接口獲取泛型變量的所有信息。

下面我們分別來看看類中定義泛型變量和方法中定義泛型變量的用法以及泛型變量信息的獲取。

類中定義泛型變量

語法

class 類名<泛型變量1,泛型變量2,泛型變量3 extends 上邊界1,泛型變量4 extends 上邊界類型1 & 上邊界類型2 & 上邊界類型3>

泛型變量需要在類名后面的括號中定義
每個類中可以定義多個泛型變量，多個泛型變量之間用逗號隔開
泛型變量可以通過extends關鍵字指定上邊界，上邊界可以對泛型變量起到了限定的作用，上邊界可以指定0到多個，多個之間需要用&符號隔開，如果不指定上邊界，默認上邊界為Object類型

案例代碼

package com.javacode2018.chat05.demo11;

import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

interface Demo1I1 { //@1
}

interface Demo1I2 { //@2
}

/**
 * 類中泛型變量案例
 *
 * @param <T1>
 * @param <T2>
 * @param <T3>
 */
public class Demo1<T1, T2 extends Integer, T3 extends Demo1I1 & Demo1I2> { //@3

    public static void main(String[] args) {
        TypeVariable<Class<Demo1>>[] typeParameters = Demo1.class.getTypeParameters();//@4
        for (TypeVariable<Class<Demo1>> typeParameter : typeParameters) {
            System.out.println("變量名稱:" + typeParameter.getName());
            System.out.println("這個變量在哪聲明的:" + typeParameter.getGenericDeclaration());
            Type[] bounds = typeParameter.getBounds();
            System.out.println("這個變量上邊界數量:" + bounds.length);
            System.out.println("這個變量上邊界清單:");
            for (Type bound : bounds) {
                System.out.println(bound.getTypeName());
            }
            System.out.println("--------------------");
        }
    }
}

代碼解讀：

@1：創建了接口Demo1I1，后面會用到

@2：創建接口Demo1I2，后面會用到這個接口

@3：創建了一個類Demo1，注意這個類是泛型類型的，泛型中定義了3個泛型類型變量，分別是：T1、T2、T3，這三個變量是有區別的。

T1沒有限制上邊界，默認上邊界就是Object類型了。

注意T2的寫法:

T2 extends Integer

這個通過extends限定了T2的上邊界為Integer。

再來看看T3的寫法，比較特別：

T3 extends I1 & I2

T3的上邊界有多個，多個邊界之間需要用&連接起來，T3有2個上邊界，分別是兩個接口Demo1I1和Demo1I2。

@4：這行代碼用來調用了Class對象的getTypeParameters方法，這個方法會返回當前類上定義的泛型變量類型列表，當前類上定義了3個泛型變量類型，泛型變量類型在java中使用TypeVariable接口表示的。

后面的for循環就是輸出泛型變量的信息了，我們來運行一下看看效果：

變量名稱:T1
這個變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個變量上邊界數量:1
這個變量上邊界清單:
java.lang.Object
--------------------
變量名稱:T2
這個變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個變量上邊界數量:1
這個變量上邊界清單:
java.lang.Integer
--------------------
變量名稱:T3
這個變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個變量上邊界數量:2
這個變量上邊界清單:
com.javacode2018.chat05.demo11.Demo1I1
com.javacode2018.chat05.demo11.Demo1I2
--------------------

輸出中可以看到3個泛型變量都是在當前類Demo1中定義的，每個泛型變量的名稱，以及泛型變量的上邊界信息都詳細輸出來了。

方法中定義泛型變量

語法

方法修飾符 <泛型變量1,泛型變量2,泛型變量3 extends 上邊界1,泛型變量4 extends 上邊界類型1 & 上邊界類型2 & 上邊界類型3> 方法名稱(參數1類型 參數1名稱,參數2類型 參數2名稱)

泛型變量需要在方法名稱前面的括號中定義
方法中可以定義多個泛型變量，多個泛型變量之間用逗號隔開
泛型變量可以通過extends關鍵字指定上邊界，上邊界可以對泛型變量起到了限定的作用，上邊界可以指定0到多個，多個之間需要用&符號隔開，如果不指定上邊界，默認上邊界為Object類型

案例代碼

package com.javacode2018.chat05.demo11;


import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

interface Demo2I1 { //@1
}

interface Demo2I2 { //@2
}

/**
 * 泛型方法中的泛型變量
 */
public class Demo2 {

    public <T1, T2 extends Integer, T3 extends Demo2I1 & Demo2I2> T3 m1(T1 t1, T2 t2, T3 t3, String s) {//@3
        return t3;
    }

    public static void main(String[] args) {
        //獲取Demo2中聲明的所有方法
        Method[] methods = Demo2.class.getDeclaredMethods();
        Method m1 = null;
        //找到m1方法
        for (Method method : methods) {
            if (method.getName().equals("m1")) {
                m1 = method;
                break;
            }
        }

        //獲取方法的泛型參數列表
        System.out.println("m1方法參數類型列表信息:----------");
        Type[] genericParameterTypes = m1.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            //3個參數都是泛型變量類型的，對應java中的TypeVariable
            if (genericParameterType instanceof TypeVariable) {
                TypeVariable pt = (TypeVariable) genericParameterType;
                System.out.println("變量類型名稱:" + pt.getTypeName());
                System.out.println("變量名稱:" + pt.getName());
                System.out.println("這個變量在哪聲明的:" + pt.getGenericDeclaration());
                Type[] bounds = pt.getBounds();
                System.out.println("這個變量上邊界數量:" + bounds.length);
                System.out.println("這個變量上邊界清單:");
                for (Type bound : bounds) {
                    System.out.println(bound.getTypeName());
                }
            } else if (genericParameterType instanceof Class) {
                Class pt = (Class) genericParameterType;
                System.out.println("參數類型名稱:" + pt.getTypeName());
                System.out.println("參數類名:" + pt.getName());
            }
            System.out.println("--------------------");
        }

        //獲取方法的返回值，也是一個泛型變量
        System.out.println("m1方法返回值類型信息:----------");
        Type genericReturnType = m1.getGenericReturnType();
        if (genericReturnType instanceof TypeVariable) {
            TypeVariable pt = (TypeVariable) genericReturnType;
            System.out.println("變量名稱:" + pt.getName());
            System.out.println("這個變量在哪聲明的:" + pt.getGenericDeclaration());
            Type[] bounds = pt.getBounds();
            System.out.println("這個變量上邊界數量:" + bounds.length);
            System.out.println("這個變量上邊界清單:");
            for (Type bound : bounds) {
                System.out.println(bound.getTypeName());
            }
            System.out.println("--------------------");
        }

        //獲取方法中聲明的泛型參數列表
        System.out.println("m1方法中聲明的泛型變量類型列表:----------");
        TypeVariable<Method>[] typeParameters = m1.getTypeParameters();
        for (TypeVariable<Method> pt : typeParameters) {
            System.out.println("變量類型名稱:" + pt.getTypeName());
            System.out.println("變量名稱:" + pt.getName());
            System.out.println("這個變量在哪聲明的:" + pt.getGenericDeclaration());
            Type[] bounds = pt.getBounds();
            System.out.println("這個變量上邊界數量:" + bounds.length);
            System.out.println("這個變量上邊界清單:");
            for (Type bound : bounds) {
                System.out.println(bound.getTypeName());
            }
            System.out.println("--------------------");
        }

    }
}

@1 @2聲明接口，下面會使用。

@3 這行比較特別，創建了一個方法，如下：

public <T1, T2 extends Integer, T3 extends Demo2I1 & Demo2I2> T3 m1(T1 t1, T2 t2, T3 t3, String s)

m1方法前面的<>括號中定義了3個泛型類型變量，方法有4個參數，前3個參數的類型為泛型變量類型的，第4個參數為String類型的。

泛型變量類型在java中使用TypeVariable表示，前3個參數都是泛型變量類型的，所以最后他們的信息都可以使用TypeVariable接口獲取，最后一個參數是String類型的，這個是非泛型類型，使用Class類型來表示。

上面代碼中先獲取m1方法對應的Method對象，然后通過Method中的方法獲取了方法參數的列表，方法的返回值詳細的泛型信息，方法中聲明的3個泛型變量的詳細信息。

泛型類型

泛型類型定義的語法

具體類型<類型1,類型2,類型3>

泛型類型可以作為方法的參數、方法的返回值、泛型類（這3種一會舉例）
<>中的泛型的實際參數列表，可以有多個，可以是任意類型的，比如：String類型、自定義類型、泛型變量類型、泛型通配符類型(?表示通配符，這個一會后面會講)
泛型類型的信息在java中使用ParameterizedType接口來表示，可以通過這個接口作為入口獲取泛型的具體詳細信息。

比如：List<String>、Map<Integer,String>、UserMapper<UserModel>，List<?>這些都是泛型類型，這些泛型的信息都可以通過ParameterizedType來表示，然后通過這個接口中的方法獲取這些泛型的具體信息。

下面來詳解3種泛型類型。

方法中泛型參數和泛型返回值

方法的參數為泛型類型或者返回值為泛型類型，我們來獲取這些泛型類型的信息。

案例代碼

package com.javacode2018.chat05.demo11;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 泛型參數
 */
public class Demo4<T> {//@0

    public class C1 {//@1
        /**
         * m1方法參數和返回值都是泛型類型，泛型的實際類型是泛型變量類型T，T是在Demo4中聲明的
         *
         * @param list
         * @return
         */
        public List<T> m1(List<T> list) {//@2
            //對list做一些操作
            return list;
        }
    }


    public static void main(String[] args) throws NoSuchMethodException {
        //獲取m1方法
        Method m1 = Demo4.C1.class.getMethod("m1", List.class);
        //調用Method中的getGenericParameterTypes方法可以獲取參數類型列表，包含了詳細的泛型信息
        Type arg1Type = m1.getGenericParameterTypes()[0];
        //m1方法有1個參數是泛型類型的，泛型類型java中用ParameterizedType接口表示
        System.out.println("----------m1方法參數類型信息------------");
        if (arg1Type instanceof ParameterizedType) {//@3
            ParameterizedType parameterizedType = (ParameterizedType) arg1Type;
            System.out.println("原始類型：" + parameterizedType.getRawType());
            System.out.println("所屬的類型:" + parameterizedType.getOwnerType());
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            //泛型中第一個參數的類型是T，T是泛型變量，泛型變量對應java中的TypeVariable接口
            Type oneType = actualTypeArguments[0];//@4
            System.out.println("@5:" + oneType.getClass());//@5
            if (oneType instanceof TypeVariable) {
                System.out.println("這個參數是個泛型變量類型！");
                TypeVariable<Class<Demo4>> oneActualType = (TypeVariable) oneType;
                System.out.println("變量名稱:" + oneActualType.getName());
                System.out.println("這個變量在哪聲明的:" + oneActualType.getGenericDeclaration());
                Type[] bounds = oneActualType.getBounds();
                System.out.println("這個變量上邊界數量:" + bounds.length);
                System.out.println("這個變量上邊界清單:");
                for (Type bound : bounds) {
                    System.out.println(bound.getTypeName());
                }
            }
        }

        System.out.println("----------m1方法返回值類型信息------------");
        //m1方法返回值是泛型類型的，泛型類型java中用ParameterizedType接口表示
        //Method類中的getGenericReturnType方法可以獲取方法的返回值，如果返回值是泛型類型的，會獲取泛型類型對應的具體類型，此處返回的是List<String>類型的，java中使用ParameterizedType接口表示
        Type returnType = m1.getGenericReturnType();
        if (returnType instanceof ParameterizedType) {//@6
            ParameterizedType parameterizedType = (ParameterizedType) returnType;
            System.out.println("原始類型：" + parameterizedType.getRawType());
            System.out.println("所屬的類型:" + parameterizedType.getOwnerType());
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            //泛型中第一個參數的類型是T，T是泛型變量，泛型變量對應java中的TypeVariable接口
            Type oneType = actualTypeArguments[0];//@7
            System.out.println("@8:" + oneType.getClass());//@8
            if (oneType instanceof TypeVariable) {
                System.out.println("返回值是個泛型變量類型！");
                TypeVariable<Class<Demo4>> oneActualType = (TypeVariable) oneType;
                System.out.println("變量名稱:" + oneActualType.getName());
                System.out.println("這個變量在哪聲明的:" + oneActualType.getGenericDeclaration());
                Type[] bounds = oneActualType.getBounds();
                System.out.println("這個變量上邊界數量:" + bounds.length);
                System.out.println("這個變量上邊界清單:");
                for (Type bound : bounds) {
                    System.out.println(bound.getTypeName());
                }
                System.out.println("--------------------");
            }
        }
    }

}

代碼解讀：

@0：Demo1<T>聲明了一個泛型類型的變量T；T是個泛型類型的變量，泛型類型的變量在java中使用TypeVariable來表示。

@1：創建了一個類C1，注意這個類是在Demo1的內部聲明的，說明C1是一個內部類。

@2：創建了方法m1，m1的參數和返回值都是泛型類型的List<T>，泛型類型在java中用ParameterizedType接口表示；而List<T>泛型類型中還有一個類型T，T是泛型變量類型的，在java中使用TypeVariable接口表示。

上面代碼中輸出了m1方法參數的泛型的詳細信息。

我們來運行看一下結果：

----------m1方法參數類型信息------------
原始類型：interface java.util.List
所屬的類型:null
@5:class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
這個參數是個泛型變量類型！
變量名稱:T
這個變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo4
這個變量上邊界數量:1
這個變量上邊界清單:
java.lang.Object
----------m1方法返回值類型信息------------
原始類型：interface java.util.List
所屬的類型:null
@8:class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
返回值是個泛型變量類型！
變量名稱:T
這個變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo4
這個變量上邊界數量:1
這個變量上邊界清單:
java.lang.Object
--------------------

泛型類

泛型類的定義

類修飾符 類名<類型1,類型2,類型n>{
}

上面是定義了一個泛型類，<>中包含的是一些可以變類型的列表，實際上我們創建這個類的對象的時候，會明確指定<>中包含的具體類型。

比如我們熟悉的HashMap就是一個泛型類，來看看這個類的定義：

public class HashMap<K,V>

K和V是泛型變量類型的，具體是什么類型，可以在創建HashMap的時候去隨意指定。

現在我們想獲取泛型對象<>中包含的具體的類型，怎么獲取？

比如下面代碼：

package com.javacode2018.chat05.demo11;

public class Demo5<T1, T2> { //@1
    public void m1(Demo5<T1, T2> demo) { //@2
        System.out.println(demo.getClass());
    }

    public static void main(String[] args) {
        Demo5<String, Integer> demo5 = new Demo5<>();//@3
        demo5.m1(demo5);
    }
}

@1：Demo5類中定義了兩個泛型變量類型T1和T2。

@2：m1方法參數類型為Demo5，在這個方法內部如果我們想獲取這個參數具體的詳細類型信息，上面的代碼是獲取不到的，只能獲取到demo5參數所屬的類型是Demo5，但是無法獲取到Demo5中的T1和T2這兩個泛型變量類型對應的具體類型。

運行一下上面代碼輸出：

class com.javacode2018.chat05.demo11.Demo5

Class對象中有個方法比較牛逼：

public Type getGenericSuperclass()

這個方法相當牛逼，可以獲取到父類中泛型詳細信息。

來看一個案例就明白了：

package com.javacode2018.chat05.demo11;

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

//泛型類
class Demo<T1, T2> {//@0

}

public class Demo6 extends Demo<String, Integer> { //@1

    public static void main(String[] args) {
        Demo6 demo6 = new Demo6();
        //demo6Class對應的是Demo6的Class對象
        Class<? extends Demo6> demo6Class = demo6.getClass();//@2

        //獲取Demo6的父類的詳細類型信息，包含泛型信息
        Type genericSuperclass = demo6Class.getGenericSuperclass(); //@3
        // 泛型類型用ParameterizedType接口表示，輸出看一下是不是這個接口類型的
        System.out.println(genericSuperclass.getClass()); //@4
        if (genericSuperclass instanceof ParameterizedType) { //@5
            ParameterizedType pt = (ParameterizedType) genericSuperclass;
            System.out.println(pt.getRawType());
            Type[] actualTypeArguments = pt.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument.getTypeName());
            }
            System.out.println(pt.getOwnerType());
        }
    }

}

運行輸出：

com.javacode2018.chat05.demo11.Demo6
class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
class com.javacode2018.chat05.demo11.Demo
java.lang.String
java.lang.Integer
null

代碼解讀：

@0：聲明了一個泛型類，泛型類中定義了兩個泛型變量的類型T1和T2，這兩個變量的具體類型，可以在創建對象的時候指定任意具體的類型。

@1：這個比較特殊了，創建了類Demo6，這個類繼承了Demo類，並且注意Demo后面的部分<String, Integer>，這個指定了具體的類型了，此時T1的具體類型就是String類型了，T2對應的具體類型就是Integer類型了。

@2：獲取Demo6對應的Class對象

@3：這行代碼比較關鍵，這個調用了Class類中的getGenericSuperclass方法，這個方法可以獲取當前類父類的具體類型信息，如果父類是泛型，則會返回泛型詳細信息，泛型類型在java中用ParameterizedType接口表示，所以@3代碼返回的類型一定是ParameterizedType接口類型的了。

@4：輸出了genericSuperclass變量的類型，注意上面第2行輸出：ParameterizedTypeImpl，這個是ParameterizedType接口的一個實現類。

@5：這個地方加了個判斷，判斷是不是ParameterizedType類型的，然后if內部輸出了泛型類型的具體的信息，調用了ParameterizedType接口中的3個方法去獲取了具體的參數類型的信息，輸出中的5/6行可以看到輸出了具體的類型String和Integer。

根據上面代碼的原理，我們可以將下面的代碼進行改造：

package com.javacode2018.chat05.demo11;

public class Demo5<T1, T2> { //@1
    public void m1(Demo5<T1, T2> demo5) { //@2
        System.out.println(demo5.getClass());
    }

    public static void main(String[] args) {
        Demo5<String, Integer> demo5 = new Demo5<>();//@3
        demo5.m1(demo5);
    }
}

如果我們想獲取Demo5的具體信息，需要給Demo5創建一個之類才可以，此處我們可以使用java中的匿名內部類來友好的解決這個問題，將上面代碼變換一下，變成下面這樣：

package com.javacode2018.chat05.demo11;

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

public class Demo5<T1, T2> { //@1
    public void m1(Demo5<T1, T2> demo) { //@2
        //demo6Class對應的是Demo6的Class對象
        Class<? extends Demo5> demoClass = demo.getClass();
        //獲取Demo6的父類的詳細類型信息，包含泛型信息
        Type genericSuperclass = demoClass.getGenericSuperclass();
        // 泛型類型用ParameterizedType接口表示，輸出看一下是不是這個接口類型的
        System.out.println(genericSuperclass.getClass());
        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericSuperclass;
            System.out.println(pt.getRawType());
            Type[] actualTypeArguments = pt.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument.getTypeName());
            }
            System.out.println(pt.getOwnerType());
        }
    }

    public static void main(String[] args) {
        Demo5<String, Integer> demo5 = new Demo5<String, Integer>() {
        };//@3
        demo5.m1(demo5);
    }
}

關鍵代碼在@3，這個地方利用了一個匿名內部類，相當於創建了Demo5的一個子類，並且指定了Demo5中兩個泛型變量類型的具體類型。

運行代碼輸出：

class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
class com.javacode2018.chat05.demo11.Demo5
java.lang.String
java.lang.Integer
null

這次我們獲取到了泛型類中具體的類型了。

這種玩法在fastjson中有用到，再來看個案例：

package com.javacode2018.chat05.demo11;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import lombok.*;

import java.io.Serializable;

public class Demo7 {
    /**
     * 通用的返回值類型
     *
     * @param <T>
     */
    @Getter
    @Setter
    @ToString
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Result<T> implements Serializable { //@1
        private String code;
        private String subCode;
        private String msg;
        private T data;
    }

    @Getter
    @Setter
    @Builder
    @ToString
    @NoArgsConstructor
    @AllArgsConstructor
    public static class UserModel { //@2
        private Integer id;
        private String name;
    }

    /**
     * 返回一個用戶信息
     *
     * @return
     */
    public static Result<UserModel> getUser() { //@3
        UserModel userModel = UserModel.builder().id(1).name("路人甲Java").build();
        Result<UserModel> result = Result.<UserModel>builder().code("1").subCode(null).msg("操作成功").data(userModel).build();
        return result;
    }

    /**
     * 用戶json信息
     *
     * @return
     */
    public static String getUserString() { //@4
        return JSON.toJSONString(getUser());
    }

    public static void main(String[] args) {
        String userString = getUserString();
        //會輸出：{"code":"1","data":{"id":1,"name":"路人甲Java"},"msg":"操作成功"}
        System.out.println(userString); //@5

        //下面我們需要將userString反序列化為Result<UserModel>對象
        Result<UserModel> userModelResult = JSON.parseObject(userString, new TypeReference<Result<UserModel>>() {
        }); //@6

        //我們來看看Result中的data是不是UserModel類型的
        System.out.println(userModelResult.getData().getClass()); //@6
    }
}

先看看運行結果：

{"code":"1","data":{"id":1,"name":"路人甲Java"},"msg":"操作成功"}
class com.javacode2018.chat05.demo11.Demo7$UserModel

@1：創建了一個Result類型的，這個類型可以作為任何接口通用的返回值類型，這個大家可以借鑒，接口有幾個通用的字段：code:狀態碼，subCode：子狀態碼，data：具體的任何類型的數據，data的具體類型可以在創建Result的時候指定，msg：接口返回的提示信息（如錯誤提示，操作成功等信息）。

@2：創建了一個用戶類

@3：這個方法模擬返回一個用戶的信息，用戶信息封裝在Result中。

@4：將用戶信息轉換為json字符串返回

@5：輸出了用戶信息字符串，也就是上面輸出中的第一行的內容。

@6：這個是上面代碼的關鍵，調用了fastjson中的方法，將字符串反序列化為Result<UserModel>，fastjson是如何獲取泛型類Result中T的具體的類型的呢，T具體的類型對應的是UserModel，關鍵代碼就是下面這行代碼：

 new TypeReference<Result<UserModel>>() {
        }

這個相當於創建了一個TypeReference類的一個子類，注意TypeReference后面尖括號中的東西，是<UserModel>，通過這個指定了泛型變量類型的具體類型，我們去看一下TypeReference類源碼，上一些關鍵代碼：

public class TypeReference<T> {
	protected TypeReference(){
        Type superClass = getClass().getGenericSuperclass(); //@1

        Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0]; //@2

        Type cachedType = classTypeCache.get(type);
        if (cachedType == null) {
            classTypeCache.putIfAbsent(type, type);
            cachedType = classTypeCache.get(type);
        }

        this.type = cachedType;
    }
}

注意上面的@1和@2是不是很熟悉了，fastjson中獲取泛型的具體類型也是讓我們采用匿名內部類去實現的，最后內部也是調用getGenericSuperclass去獲取具體的泛型類型中具體的類型的。

fastjson maven配置：

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.62</version>
</dependency>

通配符類型

通配符在java中使用?表示，例如：? extends Number和? super Integer。

java中通配符對應的類型是WildcardType接口，可以通過這個接口來獲取通配符具體的各種信息。

通配符上邊界

通配符具體的類型，可以任意指定，但是我們可以限定通配符的上邊界，上邊界指定了這個通配符能夠表示的最大的范圍的類型。

比如：？extends Integer，那么?對應的具體類型只能是Integer本身或者其子類型。

通配符上邊界

也可以給通配符指定下邊界，下邊界定義了通配符能夠表示的最小的類型。

比如：? super C1，那么?對應的具體類型只能是C1類型或者C1的父類型。

package com.javacode2018.chat05.demo11;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.List;
import java.util.Map;

public class Demo8 {
    public static class C1 { //@1
    }

    public static class C2 extends C1 { //@2
    }

    public static List<?> m1(Map<? super C2, ? extends C1> map) { //@3
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method m1 = Demo8.class.getMethod("m1", Map.class);

        //獲取m1方法參數泛型詳細參數信息
        System.out.println("獲取m1方法參數泛型詳細參數信息");
        Type[] genericParameterTypes = m1.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            // m1的參數為Map<? super C2, ? extends C1>，這個是泛型類型的，所以是ParameterizedType接口類型
            if (genericParameterType instanceof ParameterizedType) { //@4
                ParameterizedType parameterizedType = (ParameterizedType) genericParameterType; //@5
                //下面獲取Map后面兩個尖括號中的泛型參數列表，對應? super C2, ? extends C1這部分的內容，這部分在java中對應WildcardType接口類型
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); //@6
                for (Type actualTypeArgument : actualTypeArguments) {
                    if (actualTypeArgument instanceof WildcardType) {
                        WildcardType wildcardType = (WildcardType) actualTypeArgument;
                        //獲取通配符的名稱，輸出是?
                        System.out.println("通配符類型名稱:" + wildcardType.getTypeName());//@7
                        //獲取通配符的上邊界
                        Type[] upperBounds = wildcardType.getUpperBounds();
                        for (Type upperBound : upperBounds) {
                            System.out.println("通配符上邊界類型：" + upperBound.getTypeName());
                        }
                        //獲取通配符的下邊界
                        Type[] lowerBounds = wildcardType.getLowerBounds();
                        for (Type lowerBound : lowerBounds) {
                            System.out.println("通配符下邊界類型:" + lowerBound.getTypeName());
                        }
                        System.out.println("------------");
                    }
                }
            }
        }

        //獲取返回值通配符詳細信息
        System.out.println("獲取m1方法返回值泛型類型詳細信息");
        Type genericReturnType = m1.getGenericReturnType();
        // m1的返回值是List<?>，這個是個泛型類型，對應ParameterizedType接口，泛型中的具體類型是個通配符類型，通配符對應WildcardType接口類型
        if (genericReturnType instanceof ParameterizedType) { //@4
            ParameterizedType parameterizedType = (ParameterizedType) genericReturnType; //@5
            //下面獲取List面兩個尖括號中的泛型參數列表，對應?這部分的內容，這個是個通配符類型，這部分在java中對應WildcardType接口
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                if (actualTypeArgument instanceof WildcardType) {
                    WildcardType wildcardType = (WildcardType) actualTypeArgument;
                    //獲取通配符的名稱，輸出是?
                    System.out.println("通配符類型名稱:" + wildcardType.getTypeName());
                    //獲取通配符的上邊界
                    Type[] upperBounds = wildcardType.getUpperBounds();
                    for (Type upperBound : upperBounds) {
                        System.out.println("通配符上邊界類型：" + upperBound.getTypeName());
                    }
                    //獲取通配符的下邊界
                    Type[] lowerBounds = wildcardType.getLowerBounds();
                    for (Type lowerBound : lowerBounds) {
                        System.out.println("通配符下邊界類型:" + lowerBound.getTypeName());
                    }
                    System.out.println("------------");
                }
            }
        }
    }

}

輸出：

獲取m1方法參數泛型詳細參數信息
通配符類型名稱:? super com.javacode2018.chat05.demo11.Demo8$C2
通配符上邊界類型：java.lang.Object
通配符下邊界類型:com.javacode2018.chat05.demo11.Demo8$C2
------------
通配符類型名稱:? extends com.javacode2018.chat05.demo11.Demo8$C1
通配符上邊界類型：com.javacode2018.chat05.demo11.Demo8$C1
------------
獲取m1方法返回值泛型類型詳細信息
通配符類型名稱:?
通配符上邊界類型：java.lang.Object
------------

具體的就不解釋了，只需要注意一點?通配符的信息使用WildcardType接口表示，可以通過這個接口獲取通配符的詳細信息。

泛型數組

什么是泛型數組？

數組中的元素為泛型，那么這個數組就是泛型類型的數組，泛型數組在java中使用GenericArrayType接口來表示，可以通過這個接口提供的方法獲取泛型數組更詳細的信息。

如：List<String> list []; List<String> list [][];

泛型數組類型的可以作為方法的參數、方法的返回值、泛型類的具體類型、字段的類型等等。

下面就以泛型字段來舉例，一起來獲取泛型字段的詳細信息。

package com.javacode2018.chat05.demo11;

import java.lang.reflect.*;
import java.util.List;
import java.util.Map;

public class Demo9 {

    List<String> list[]; //@1

    public static void main(String[] args) throws NoSuchFieldException {
        Field list = Demo9.class.getDeclaredField("list");
        //獲取字段的泛型類型
        Type genericType = list.getGenericType(); //@2
        //看看字段的具體泛型類型
        System.out.println(genericType.getClass()); //@3
        if (genericType instanceof GenericArrayType) {
            GenericArrayType genericArrayType = (GenericArrayType) genericType;
            //獲取數組的具體類型，具體的類型就是List<String>，這個是個泛型類型，對應java中的ParameterizedType接口
            Type genericComponentType = genericArrayType.getGenericComponentType();//@4
            System.out.println(genericComponentType.getClass());
            if (genericComponentType instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) genericComponentType;
                System.out.println(parameterizedType.getRawType());
                //調用getActualTypeArguments()獲取List<String>中尖括號中的參數列表
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//@5
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument.getTypeName());
                }
                System.out.println(parameterizedType.getOwnerType());
            }

        }
    }

}

運行輸出：

class sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
interface java.util.List
java.lang.String
null

代碼解讀：

@1：聲明了一個泛型類型的數組。

@2：獲取list字段對應的泛型數組類型，泛型數組在java中使用GenericArrayType表示，所以@3輸出是GenericArrayType接口類型的。

@4：調用GenericArrayType接口中的getGenericComponentType方法會返回數組的具體的泛型類型，這個地方對應的就是List<String>，這個是個泛型類型，泛型類型在java中使用ParameterizedType接口表示的。

@5：調用了ParameterizedType接口中的getActualTypeArguments方法，這個方法可以獲取泛型類型中具體的類型列表，就是List后面尖括號中的參數列表。

綜合案例

代碼如下：

package com.javacode2018.chat05.demo11;


import java.util.List;
import java.util.Map;

public class Demo10<K, V> {

    Map<String, ? extends List<? extends Map<K, V>>> [][] map;
}

上面這個挺復雜的，我們一步步拆解解析一下，步驟如下：

1、Demo10<K, V>：  --------> 對應java中的Class對象
2、<K, V>：定義了2個泛型變量，泛型變量對應TypeVariable接口
3、Map<String, ? extends List<? extends Map<K, V>>> [][]map：定義了一個二維泛型數組，泛型數組用GenericArrayType接口表示
4、map中的每個元素是這個是Map<String, ? extends List<? extends Map<K, V>>> []類型的，是一個一維泛型數組，泛型數組用GenericArrayType接口表示。
5、再繼續拆解，Map<String, ? extends List<? extends Map<K, V>>> []中每個元素是Map<String, ? extends List<? extends Map<K, V>>>泛型類型的，泛型類型在java中使用ParameterizedType接口表示
6、拆解Map<String, ? extends List<? extends Map<K, V>>>后面尖括號中的參數列表，可以調用ParameterizedType接口的Type[] getActualTypeArguments()方法獲取，Map后面的尖括號中有2個參數，分別是String和? extends List<? extends Map<K, V>>
7、String是java中定義的類型，對應java中的Class對象
8、? extends List<? extends Map<K, V>>是通配符類型的，對應WildcardType接口，通配符指定了上邊界，上邊界是List<? extends Map<K, V>>
9、List<? extends Map<K, V>>又是一個泛型類型，泛型類型對應ParameterizedType接口，List<? extends Map<K, V>>的尖括號中又定義了這個泛型類型的具體的類型? extends Map<K, V>
10、? extends Map<K, V>又是一個通配符類型，對應WildcardType接口,這個通配符指定了上邊界為Map<K,V>
11、Map<K,V>又對應泛型類型，泛型類型對應ParameterizedType接口，調用這個接口的getActualTypeArguments()方法獲取泛型中的參數列表K和V
12、K和V是Demo10中定義的泛型變量類型，泛型變量類型對應TypeVariable接口

按照上面的思路，我們來完善一下解析代碼：

package com.javacode2018.chat05.demo11;


import sun.security.util.Length;

import java.lang.reflect.*;
import java.util.List;
import java.util.Map;

public class Demo10<K, V> {

    Map<String, ? extends List<? extends Map<K, V>>>[][] map;

    public static void parseType(Type type, int level) {
        String whileString = whileString(level);
        if (type instanceof GenericArrayType) {
            System.out.println(whileString + "泛型數組類型:" + type);
            parseType(((GenericArrayType) type).getGenericComponentType(), ++level);
        } else if (type instanceof ParameterizedType) {
            System.out.println(whileString + "泛型類型:" + type);
            ParameterizedType parameterizedType = (ParameterizedType) type;
            System.out.println(whileString + "實際類型:" + parameterizedType.getRawType());
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            System.out.println(whileString + actualTypeArguments.length + "個泛型參數,如下：");
            int count = 0;
            for (Type actualTypeArgument : actualTypeArguments) {
                if (count++ == 0) {
                    level++;
                }
                parseType(actualTypeArgument, level);
            }
        } else if (type instanceof WildcardType) {
            System.out.println(whileString + "通配符類型:" + type);
            WildcardType wildcardType = ((WildcardType) type);
            System.out.println(whileString + "通配符類型名稱:" + wildcardType.getTypeName());
            Type[] upperBounds = wildcardType.getUpperBounds();
            System.out.println(whileString + "上邊界列表");
            int count = 0;
            for (Type upperBound : upperBounds) {
                if (count++ == 0) {
                    level++;
                }
                parseType(upperBound, level);
            }
            System.out.println(whileString + "下邊界列表");
            Type[] lowerBounds = wildcardType.getLowerBounds();
            for (Type lowerBound : lowerBounds) {
                if (count++ == 0) {
                    level++;
                }
                parseType(lowerBound, level);
            }
        } else if (type instanceof TypeVariable) {
            System.out.println(whileString + "泛型變量類型:" + type);
            TypeVariable typeVariable = ((TypeVariable) type);
            Type[] bounds = typeVariable.getBounds();
            System.out.println(whileString + "泛型變量上邊界列表");
            int count = 0;
            for (Type bound : bounds) {
                if (count++ == 0) {
                    level++;
                }
                parseType(bound, level);
            }
        } else if (type instanceof Class) {
            System.out.println(whileString + "普通類型:" + ((Class) type).getName());
        }
    }

    public static String whileString(int count) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) {
            sb.append("----");
        }
        return sb.toString();
    }

    public static void main(String[] args) throws NoSuchFieldException {
        parseType(Demo10.class.getDeclaredField("map").getGenericType(), 0);
    }
}

運行輸出：

泛型數組類型:java.util.Map<java.lang.String, ? extends java.util.List<? extends java.util.Map<K, V>>>[][]
----泛型數組類型:java.util.Map<java.lang.String, ? extends java.util.List<? extends java.util.Map<K, V>>>[]
--------泛型類型:java.util.Map<java.lang.String, ? extends java.util.List<? extends java.util.Map<K, V>>>
--------實際類型:interface java.util.Map
--------2個泛型參數,如下：
------------普通類型:java.lang.String
------------通配符類型:? extends java.util.List<? extends java.util.Map<K, V>>
------------通配符類型名稱:? extends java.util.List<? extends java.util.Map<K, V>>
------------上邊界列表
----------------泛型類型:java.util.List<? extends java.util.Map<K, V>>
----------------實際類型:interface java.util.List
----------------1個泛型參數,如下：
--------------------通配符類型:? extends java.util.Map<K, V>
--------------------通配符類型名稱:? extends java.util.Map<K, V>
--------------------上邊界列表
------------------------泛型類型:java.util.Map<K, V>
------------------------實際類型:interface java.util.Map
------------------------2個泛型參數,如下：
----------------------------泛型變量類型:K
----------------------------泛型變量上邊界列表
--------------------------------普通類型:java.lang.Object
----------------------------泛型變量類型:V
----------------------------泛型變量上邊界列表
--------------------------------普通類型:java.lang.Object
--------------------下邊界列表
------------下邊界列表

上將map這個屬性詳細的泛型信息都輸出出來了，重點在於上面的parseType方法，java中的類型無非就是5種表示類型，這個方法內部使用遞歸來解析這些類型。

總結

泛型解析需要一步步拆解，會被拆解為5中類型中的一種，需要理解5中類型分別對應什么，這個是關鍵
本篇內容比較多，建議每個案例大家都去自己寫一下，體驗一下，加深理解
如果對泛型有任何疑問的可以留言交流