• 引入
• • Type接口
  • Class類
  • Method類
  • Field類
  • ParameterizedType接口
  • TypeVariable接口
• 類中定義泛型變量
• 方法中定義泛型變量
• • 方法中泛型參數(shù)和泛型返回值
• 泛型數(shù)組

---

引入

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

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

下面一個(gè)個(gè)來解釋。

Type接口

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

這個(gè)接口代碼比較簡單，源碼：

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

這個(gè)接口只有一個(gè)方法，用于返回具體類型的名稱，是一個(gè)默認(rèn)方法，默認(rèn)會調(diào)用當(dāng)前類的toString方法，實(shí)現(xiàn)類也可以對這個(gè)方法重寫。getTypeName

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

public TypeVariable<?>[] getTypeParameters()
這個(gè)方法用于獲取聲明的泛型變量類型清單。

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

類中定義泛型變量類型
public class Demo1<T1, T2 extends Integer, T3 extends Demo1I1 & Demo1I2>
上面代碼表示Demo1這個(gè)類中聲明了3個(gè)泛型變量類型：T1、T2、T3，所以如果去調(diào)用這個(gè)類的Clas對象中的getTypeParameters方法可以獲取到這三個(gè)泛型變量的信息，文章后面有案例演示。

方法中定義泛型變量類型
public <T1, T2 extends Integer, T3 extends Demo2I1 & Demo2I2> T3 m1(T1 t1, T2 t2, T3 t3, String s) {
return t3;
}
上面m1方法中聲明了三個(gè)泛型類型變量：T1、T2、T3；java中可以方法的任何信息都可以通過Method對象來獲取，Mehod類實(shí)現(xiàn)了GenericDeclaration接口，所以Method類中實(shí)現(xiàn)了GenericDeclaration接口中的getTypeParameters方法，調(diào)用這個(gè)方法就可以獲取m1方法中3個(gè)泛型變量類型的信息，文章后面有案例演示。

Class類

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

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

1.類名.class
2.對象.getClass()
3.Class.forName(“類或者接口的完整名稱”)
常用的方法
Field[] getFields()
這個(gè)方法會返回當(dāng)前類的以及其所有父類、父類的父類中所有public類型的字段。

Field[] getDeclaredFields()
這個(gè)方法會返回當(dāng)前類中所有字段（和修飾符無關(guān)），也就說不管這個(gè)字段是public還是private或者是protected，都會返回，有一點(diǎn)需要注意，只返回自己內(nèi)部定義的字段，不包含其父類中的，這點(diǎn)需要注意，和getFields是有區(qū)別的。

Method[] getMethods()
這個(gè)方法會返回當(dāng)前類的以及其所有父類的、父類的父類的、自己實(shí)現(xiàn)的接口、父接口繼承的接口中的所有public類型的方法，需要注意一下，接口中的方法默認(rèn)都是public類型的，接口中的方法public修飾符是可以省略的。

Method[] getDeclaredMethods()
返回當(dāng)前類中定義的所有方法，不管這個(gè)方法修飾符是什么類型的，注意只包含自己內(nèi)部定義的方法，不包含當(dāng)前類的父類或者其實(shí)現(xiàn)的接口中定義的。

Type getGenericSuperclass()
返回父類的類型信息，如果父類是泛型類型，會返回超類中泛型的詳細(xì)信息，這個(gè)方法比較關(guān)鍵，后面會有詳細(xì)案例。

TypeVariable<Class>[] getTypeParameters()
Class類繼承了接口，上面這個(gè)方法是在GenericDeclaration接口中定義的，Class類中實(shí)現(xiàn)了這個(gè)接口，用于返回當(dāng)前類中聲明的泛型變量參數(shù)列表。java.lang.reflect.GenericDeclaration

Method類

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

常用的方法
String getName()
用來獲取方法的名稱。

Type[] getGenericParameterTypes()
返回方法的參數(shù)信息，如果參數(shù)是泛型類型的，會返回泛型的詳細(xì)信息，這個(gè)方法后面會演示。

Type getGenericReturnType()
返回方法的返回值類型，如果返回值是泛型的，會包含泛型的詳細(xì)信息。

TypeVariable[] getTypeParameters()
Method類繼承了接口，上面這個(gè)方法是在GenericDeclaration接口中定義的，Method類中實(shí)現(xiàn)了這個(gè)接口，用于返回當(dāng)前方法中聲明的泛型變量參數(shù)列表。java.lang.reflect.GenericDeclaration

Field類

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

常用的方法
String getName()
獲取字段的名稱。

Class<?> getType()
獲取字段類型所屬的Class對象。

Type getGenericType()
獲取字段的類型，如果字段是泛型類型的，會返回泛型類型的詳細(xì)信息；如果字段不是泛型類型的，和getType返回的結(jié)果是一樣的。

Class<?> getDeclaringClass()
獲取這個(gè)字段是在哪個(gè)類中聲明的，也就是當(dāng)前字段所屬的類。

ParameterizedType接口

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

常用方法
這個(gè)接口中定義了3個(gè)方法，都比較重要，來看一下。

Type[] getActualTypeArguments()
獲取泛型類型中的類型列表，就是<>中包含的參數(shù)列表，如：List泛型類型列表只有一個(gè)是String，而Map<Integer,String>泛型類型中包含2個(gè)類型：Integer和String，UserMapper泛型類型為UserModel，實(shí)際上就是<和>中間包含的類型列表。

Type getRawType()
返回參數(shù)化類型中的原始類型，比如：List的原始類型為List，UserMapper原始類型為UserMapper，也就是<符號前面的部分。

Type[] getOwnerType()
返回當(dāng)前類型所屬的類型。例如存在A類，其中定義了內(nèi)部類InnerA，則InnerA所屬的類型為A，如果是頂層類型則返回null。這種關(guān)系比較常見的示例是Map<K,V>接口與Map.Entry<K,V>接口，Map<K,V>接口是Map.Entry<K,V>接口的所有者。

TypeVariable接口

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

常用的方法
Type[] getBounds()
獲取泛型變量類型的上邊界，如果未明確什么上邊界默認(rèn)為Object。例如：class Test中K的上邊界只有一個(gè)，是Person；而class Test<T extend List & Iterable>中T的上邊界有2個(gè)，是List和Iterable

D getGenericDeclaration()
獲取聲明該泛型變量的原始類型，例如：class Test中的K為泛型變量，這個(gè)泛型變量時(shí)Test類定義的時(shí)候聲明的，說明如果調(diào)用getGenericDeclaration方法返回的就是Test對應(yīng)的Class對象。

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

String getName()
獲取在源碼中定義時(shí)的名字，如：class Test就是K；class Test1中就是T。

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

常用方法
接口中定義了2個(gè)方法。

Type[] getUpperBounds()
返回泛型變量的上邊界列表。

Type[] getLowerBounds()
返回泛型變量的下邊界列表。

GenericArrayType接口
表示的是數(shù)組類型，且數(shù)組中的元素是ParameterizedType或者TypeVariable。

例如：List[]或者T[]。

常用方法
這個(gè)接口只有一個(gè)方法：

Type getGenericComponentType()
這個(gè)方法返回?cái)?shù)組的組成元素。

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

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

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

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

類中定義泛型變量

語法
class 類名<泛型變量1,泛型變量2,泛型變量3 extends 上邊界1,泛型變量4 extends 上邊界類型1 & 上邊界類型2 & 上邊界類型3>
泛型變量需要在類名后面的括號中定義

每個(gè)類中可以定義多個(gè)泛型變量，多個(gè)泛型變量之間用逗號隔開

泛型變量可以通過extends關(guān)鍵字指定上邊界，上邊界可以對泛型變量起到了限定的作用，上邊界可以指定0到多個(gè)，多個(gè)之間需要用&符號隔開，如果不指定上邊界，默認(rèn)上邊界為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> { //@3public static void main(String[] args) {TypeVariable<Class<Demo1>>[] typeParameters = Demo1.class.getTypeParameters();//@4for (TypeVariable<Class<Demo1>> typeParameter : typeParameters) {System.out.println("變量名稱:" + typeParameter.getName());System.out.println("這個(gè)變量在哪聲明的:" + typeParameter.getGenericDeclaration());Type[] bounds = typeParameter.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}System.out.println("--------------------");}} }

代碼解讀：

@1：創(chuàng)建了接口Demo1I1，后面會用到

@2：創(chuàng)建接口Demo1I2，后面會用到這個(gè)接口

@3：創(chuàng)建了一個(gè)類Demo1，注意這個(gè)類是泛型類型的，泛型中定義了3個(gè)泛型類型變量，分別是：T1、T2、T3，這三個(gè)變量是有區(qū)別的。

T1沒有限制上邊界，默認(rèn)上邊界就是Object類型了。

注意T2的寫法:

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

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

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

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

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

變量名稱:T1 這個(gè)變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個(gè)變量上邊界數(shù)量:1 這個(gè)變量上邊界清單: java.lang.Object

變量名稱:T2 這個(gè)變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個(gè)變量上邊界數(shù)量:1 這個(gè)變量上邊界清單: java.lang.Integer

變量名稱:T3 這個(gè)變量在哪聲明的:class com.javacode2018.chat05.demo11.Demo1
這個(gè)變量上邊界數(shù)量:2 這個(gè)變量上邊界清單: com.javacode2018.chat05.demo11.Demo1I1
com.javacode2018.chat05.demo11.Demo1I2

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

方法中定義泛型變量

語法
方法修飾符 <泛型變量1,泛型變量2,泛型變量3 extends 上邊界1,泛型變量4 extends 上邊界類型1 & 上邊界類型2 & 上邊界類型3> 方法名稱(參數(shù)1類型 參數(shù)1名稱,參數(shù)2類型 參數(shù)2名稱)
泛型變量需要在方法名稱前面的括號中定義

方法中可以定義多個(gè)泛型變量，多個(gè)泛型變量之間用逗號隔開

泛型變量可以通過extends關(guān)鍵字指定上邊界，上邊界可以對泛型變量起到了限定的作用，上邊界可以指定0到多個(gè)，多個(gè)之間需要用&符號隔開，如果不指定上邊界，默認(rèn)上邊界為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) {//@3return 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;}}//獲取方法的泛型參數(shù)列表System.out.println("m1方法參數(shù)類型列表信息:----------");Type[] genericParameterTypes = m1.getGenericParameterTypes();for (Type genericParameterType : genericParameterTypes) {//3個(gè)參數(shù)都是泛型變量類型的，對應(yīng)java中的TypeVariableif (genericParameterType instanceof TypeVariable) {TypeVariable pt = (TypeVariable) genericParameterType;System.out.println("變量類型名稱:" + pt.getTypeName());System.out.println("變量名稱:" + pt.getName());System.out.println("這個(gè)變量在哪聲明的:" + pt.getGenericDeclaration());Type[] bounds = pt.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}} else if (genericParameterType instanceof Class) {Class pt = (Class) genericParameterType;System.out.println("參數(shù)類型名稱:" + pt.getTypeName());System.out.println("參數(shù)類名:" + pt.getName());}System.out.println("--------------------");}//獲取方法的返回值，也是一個(gè)泛型變量System.out.println("m1方法返回值類型信息:----------");Type genericReturnType = m1.getGenericReturnType();if (genericReturnType instanceof TypeVariable) {TypeVariable pt = (TypeVariable) genericReturnType;System.out.println("變量名稱:" + pt.getName());System.out.println("這個(gè)變量在哪聲明的:" + pt.getGenericDeclaration());Type[] bounds = pt.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}System.out.println("--------------------");}//獲取方法中聲明的泛型參數(shù)列表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("這個(gè)變量在哪聲明的:" + pt.getGenericDeclaration());Type[] bounds = pt.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}System.out.println("--------------------");}} }

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

@3 這行比較特別，創(chuàng)建了一個(gè)方法，如下：

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

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

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

上面代碼中先獲取m1方法對應(yīng)的Method對象，然后通過Method中的方法獲取了方法參數(shù)的列表，方法的返回值詳細(xì)的泛型信息，方法中聲明的3個(gè)泛型變量的詳細(xì)信息。

泛型類型
泛型類型定義的語法
具體類型<類型1,類型2,類型3>
泛型類型可以作為方法的參數(shù)、方法的返回值、泛型類（這3種一會舉例）

<>中的泛型的實(shí)際參數(shù)列表，可以有多個(gè)，可以是任意類型的，比如：String類型、自定義類型、泛型變量類型、泛型通配符類型(?表示通配符，這個(gè)一會后面會講)

泛型類型的信息在java中使用ParameterizedType接口來表示，可以通過這個(gè)接口作為入口獲取泛型的具體詳細(xì)信息。

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

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

方法中泛型參數(shù)和泛型返回值

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

案例代碼

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;/*** 泛型參數(shù)*/ public class Demo4<T> {//@0public class C1 {//@1/*** m1方法參數(shù)和返回值都是泛型類型，泛型的實(shí)際類型是泛型變量類型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);//調(diào)用Method中的getGenericParameterTypes方法可以獲取參數(shù)類型列表，包含了詳細(xì)的泛型信息Type arg1Type = m1.getGenericParameterTypes()[0];//m1方法有1個(gè)參數(shù)是泛型類型的，泛型類型java中用ParameterizedType接口表示System.out.println("----------m1方法參數(shù)類型信息------------");if (arg1Type instanceof ParameterizedType) {//@3ParameterizedType parameterizedType = (ParameterizedType) arg1Type;System.out.println("原始類型：" + parameterizedType.getRawType());System.out.println("所屬的類型:" + parameterizedType.getOwnerType());Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//泛型中第一個(gè)參數(shù)的類型是T，T是泛型變量，泛型變量對應(yīng)java中的TypeVariable接口Type oneType = actualTypeArguments[0];//@4System.out.println("@5:" + oneType.getClass());//@5if (oneType instanceof TypeVariable) {System.out.println("這個(gè)參數(shù)是個(gè)泛型變量類型！");TypeVariable<Class<Demo4>> oneActualType = (TypeVariable) oneType;System.out.println("變量名稱:" + oneActualType.getName());System.out.println("這個(gè)變量在哪聲明的:" + oneActualType.getGenericDeclaration());Type[] bounds = oneActualType.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}}}System.out.println("----------m1方法返回值類型信息------------");//m1方法返回值是泛型類型的，泛型類型java中用ParameterizedType接口表示//Method類中的getGenericReturnType方法可以獲取方法的返回值，如果返回值是泛型類型的，會獲取泛型類型對應(yīng)的具體類型，此處返回的是List<String>類型的，java中使用ParameterizedType接口表示Type returnType = m1.getGenericReturnType();if (returnType instanceof ParameterizedType) {//@6ParameterizedType parameterizedType = (ParameterizedType) returnType;System.out.println("原始類型：" + parameterizedType.getRawType());System.out.println("所屬的類型:" + parameterizedType.getOwnerType());Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//泛型中第一個(gè)參數(shù)的類型是T，T是泛型變量，泛型變量對應(yīng)java中的TypeVariable接口Type oneType = actualTypeArguments[0];//@7System.out.println("@8:" + oneType.getClass());//@8if (oneType instanceof TypeVariable) {System.out.println("返回值是個(gè)泛型變量類型！");TypeVariable<Class<Demo4>> oneActualType = (TypeVariable) oneType;System.out.println("變量名稱:" + oneActualType.getName());System.out.println("這個(gè)變量在哪聲明的:" + oneActualType.getGenericDeclaration());Type[] bounds = oneActualType.getBounds();System.out.println("這個(gè)變量上邊界數(shù)量:" + bounds.length);System.out.println("這個(gè)變量上邊界清單:");for (Type bound : bounds) {System.out.println(bound.getTypeName());}System.out.println("--------------------");}}}}

代碼解讀：

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

@1：創(chuàng)建了一個(gè)類C1，注意這個(gè)類是在Demo1的內(nèi)部聲明的，說明C1是一個(gè)內(nèi)部類。

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

上面代碼中輸出了m1方法參數(shù)的泛型的詳細(xì)信息。

我們來運(yùn)行看一下結(jié)果：

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

泛型類
泛型類的定義
類修飾符 類名<類型1,類型2,類型n>{
}
上面是定義了一個(gè)泛型類，<>中包含的是一些可以變類型的列表，實(shí)際上我們創(chuàng)建這個(gè)類的對象的時(shí)候，會明確指定<>中包含的具體類型。

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

public class HashMap<K,V>
K和V是泛型變量類型的，具體是什么類型，可以在創(chuàng)建HashMap的時(shí)候去隨意指定。

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

比如下面代碼：

package com.javacode2018.chat05.demo11;public class Demo5<T1, T2> { //@1public void m1(Demo5<T1, T2> demo) { //@2System.out.println(demo.getClass());}public static void main(String[] args) {Demo5<String, Integer> demo5 = new Demo5<>();//@3demo5.m1(demo5);} }

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

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

運(yùn)行一下上面代碼輸出：

class com.javacode2018.chat05.demo11.Demo5
Class對象中有個(gè)方法比較牛逼：

public Type getGenericSuperclass()
這個(gè)方法相當(dāng)牛逼，可以獲取到父類中泛型詳細(xì)信息。

來看一個(gè)案例就明白了：

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> { //@1public static void main(String[] args) {Demo6 demo6 = new Demo6();//demo6Class對應(yīng)的是Demo6的Class對象Class<? extends Demo6> demo6Class = demo6.getClass();//@2//獲取Demo6的父類的詳細(xì)類型信息，包含泛型信息Type genericSuperclass = demo6Class.getGenericSuperclass(); //@3// 泛型類型用ParameterizedType接口表示，輸出看一下是不是這個(gè)接口類型的System.out.println(genericSuperclass.getClass()); //@4if (genericSuperclass instanceof ParameterizedType) { //@5ParameterizedType 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());}}}

運(yùn)行輸出：

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：聲明了一個(gè)泛型類，泛型類中定義了兩個(gè)泛型變量的類型T1和T2，這兩個(gè)變量的具體類型，可以在創(chuàng)建對象的時(shí)候指定任意具體的類型。

@1：這個(gè)比較特殊了，創(chuàng)建了類Demo6，這個(gè)類繼承了Demo類，并且注意Demo后面的部分<String, Integer>，這個(gè)指定了具體的類型了，此時(shí)T1的具體類型就是String類型了，T2對應(yīng)的具體類型就是Integer類型了。

@2：獲取Demo6對應(yīng)的Class對象

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

@4：輸出了genericSuperclass變量的類型，注意上面第2行輸出：ParameterizedTypeImpl，這個(gè)是ParameterizedType接口的一個(gè)實(shí)現(xiàn)類。

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

根據(jù)上面代碼的原理，我們可以將下面的代碼進(jìn)行改造：

package com.javacode2018.chat05.demo11;public class Demo5<T1, T2> { //@1public void m1(Demo5<T1, T2> demo5) { //@2System.out.println(demo5.getClass());}public static void main(String[] args) {Demo5<String, Integer> demo5 = new Demo5<>();//@3demo5.m1(demo5);} }

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

package com.javacode2018.chat05.demo11;import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type;public class Demo5<T1, T2> { //@1public void m1(Demo5<T1, T2> demo) { //@2//demo6Class對應(yīng)的是Demo6的Class對象Class<? extends Demo5> demoClass = demo.getClass();//獲取Demo6的父類的詳細(xì)類型信息，包含泛型信息Type genericSuperclass = demoClass.getGenericSuperclass();// 泛型類型用ParameterizedType接口表示，輸出看一下是不是這個(gè)接口類型的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>() {};//@3demo5.m1(demo5);} }

關(guān)鍵代碼在@3，這個(gè)地方利用了一個(gè)匿名內(nèi)部類，相當(dāng)于創(chuàng)建了Demo5的一個(gè)子類，并且指定了Demo5中兩個(gè)泛型變量類型的具體類型。

運(yùn)行代碼輸出：

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

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

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

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@AllArgsConstructorpublic static class Result<T> implements Serializable { //@1private String code;private String subCode;private String msg;private T data;}@Getter@Setter@Builder@ToString@NoArgsConstructor@AllArgsConstructorpublic static class UserModel { //@2private Integer id;private String name;}/*** 返回一個(gè)用戶信息** @return*/public static Result<UserModel> getUser() { //@3UserModel 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() { //@4return 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} }

先看看運(yùn)行結(jié)果：

{“code”:“1”,“data”:{“id”:1,“name”:“路人甲Java”},“msg”:“操作成功”}
class com.javacode2018.chat05.demo11.Demo7$UserModel
@1：創(chuàng)建了一個(gè)Result類型的，這個(gè)類型可以作為任何接口通用的返回值類型，這個(gè)大家可以借鑒，接口有幾個(gè)通用的字段：code:狀態(tài)碼，subCode：子狀態(tài)碼，data：具體的任何類型的數(shù)據(jù)，data的具體類型可以在創(chuàng)建Result的時(shí)候指定，msg：接口返回的提示信息（如錯(cuò)誤提示，操作成功等信息）。

@2：創(chuàng)建了一個(gè)用戶類

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

@4：將用戶信息轉(zhuǎn)換為json字符串返回

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

@6：這個(gè)是上面代碼的關(guān)鍵，調(diào)用了fastjson中的方法，將字符串反序列化為Result，fastjson是如何獲取泛型類Result中T的具體的類型的呢，T具體的類型對應(yīng)的是UserModel，關(guān)鍵代碼就是下面這行代碼：

new TypeReference<Result>() {
}
這個(gè)相當(dāng)于創(chuàng)建了一個(gè)TypeReference類的一個(gè)子類，注意TypeReference后面尖括號中的東西，是，通過這個(gè)指定了泛型變量類型的具體類型，我們?nèi)タ匆幌耇ypeReference類源碼，上一些關(guān)鍵代碼：

public class TypeReference<T> {protected TypeReference(){Type superClass = getClass().getGenericSuperclass(); //@1Type type = ((ParameterizedType) superClass).getActualTypeArguments()[0]; //@2Type cachedType = classTypeCache.get(type);if (cachedType == null) {classTypeCache.putIfAbsent(type, type);cachedType = classTypeCache.get(type);}this.type = cachedType;} }

注意上面的@1和@2是不是很熟悉了，fastjson中獲取泛型的具體類型也是讓我們采用匿名內(nèi)部類去實(shí)現(xiàn)的，最后內(nèi)部也是調(diào)用getGenericSuperclass去獲取具體的泛型類型中具體的類型的。

fastjson maven配置：

com.alibaba fastjson 1.2.62 通配符類型 通配符在java中 使用?表示，例如：? extends Number和? super Integer。

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

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

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

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

比如：? super C1，那么?對應(yīng)的具體類型只能是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) { //@3return null;}public static void main(String[] args) throws NoSuchMethodException {Method m1 = Demo8.class.getMethod("m1", Map.class);//獲取m1方法參數(shù)泛型詳細(xì)參數(shù)信息System.out.println("獲取m1方法參數(shù)泛型詳細(xì)參數(shù)信息");Type[] genericParameterTypes = m1.getGenericParameterTypes();for (Type genericParameterType : genericParameterTypes) {// m1的參數(shù)為Map<? super C2, ? extends C1>，這個(gè)是泛型類型的，所以是ParameterizedType接口類型if (genericParameterType instanceof ParameterizedType) { //@4ParameterizedType parameterizedType = (ParameterizedType) genericParameterType; //@5//下面獲取Map后面兩個(gè)尖括號中的泛型參數(shù)列表，對應(yīng)? super C2, ? extends C1這部分的內(nèi)容，這部分在java中對應(yīng)WildcardType接口類型Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); //@6for (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("------------");}}}}//獲取返回值通配符詳細(xì)信息System.out.println("獲取m1方法返回值泛型類型詳細(xì)信息");Type genericReturnType = m1.getGenericReturnType();// m1的返回值是List<?>，這個(gè)是個(gè)泛型類型，對應(yīng)ParameterizedType接口，泛型中的具體類型是個(gè)通配符類型，通配符對應(yīng)WildcardType接口類型if (genericReturnType instanceof ParameterizedType) { //@4ParameterizedType parameterizedType = (ParameterizedType) genericReturnType; //@5//下面獲取List面兩個(gè)尖括號中的泛型參數(shù)列表，對應(yīng)?這部分的內(nèi)容，這個(gè)是個(gè)通配符類型，這部分在java中對應(yīng)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方法參數(shù)泛型詳細(xì)參數(shù)信息 通配符類型名稱:? 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方法返回值泛型類型詳細(xì)信息 通配符類型名稱:? 通配符上邊界類型：java.lang.Object

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

泛型數(shù)組

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

如：List list []; List list [][];

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

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

package com.javacode2018.chat05.demo11;import java.lang.reflect.*; import java.util.List; import java.util.Map;public class Demo9 {List<String> list[]; //@1public static void main(String[] args) throws NoSuchFieldException {Field list = Demo9.class.getDeclaredField("list");//獲取字段的泛型類型Type genericType = list.getGenericType(); //@2//看看字段的具體泛型類型System.out.println(genericType.getClass()); //@3if (genericType instanceof GenericArrayType) {GenericArrayType genericArrayType = (GenericArrayType) genericType;//獲取數(shù)組的具體類型，具體的類型就是List<String>，這個(gè)是個(gè)泛型類型，對應(yīng)java中的ParameterizedType接口Type genericComponentType = genericArrayType.getGenericComponentType();//@4System.out.println(genericComponentType.getClass());if (genericComponentType instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) genericComponentType;System.out.println(parameterizedType.getRawType());//調(diào)用getActualTypeArguments()獲取List<String>中尖括號中的參數(shù)列表Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//@5for (Type actualTypeArgument : actualTypeArguments) {System.out.println(actualTypeArgument.getTypeName());}System.out.println(parameterizedType.getOwnerType());}}}}

運(yùn)行輸出：

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

代碼解讀：

@1：聲明了一個(gè)泛型類型的數(shù)組。

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

@4：調(diào)用GenericArrayType接口中的getGenericComponentType方法會返回?cái)?shù)組的具體的泛型類型，這個(gè)地方對應(yīng)的就是List，這個(gè)是個(gè)泛型類型，泛型類型在java中使用ParameterizedType接口表示的。

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

綜合案例
代碼如下：

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

上面這個(gè)挺復(fù)雜的，我們一步步拆解解析一下，步驟如下：

1、Demo10<K, V>： --------> 對應(yīng)java中的Class對象
2、<K, V>：定義了2個(gè)泛型變量，泛型變量對應(yīng)TypeVariable接口
3、Map<String, ? extends List<? extends Map<K, V>>> [][]map：定義了一個(gè)二維泛型數(shù)組，泛型數(shù)組用GenericArrayType接口表示
4、map中的每個(gè)元素是這個(gè)是Map<String, ? extends List<? extends Map<K, V>>> []類型的，是一個(gè)一維泛型數(shù)組，泛型數(shù)組用GenericArrayType接口表示。
5、再繼續(xù)拆解，Map<String, ? extends List<? extends Map<K, V>>> []中每個(gè)元素是Map<String, ? extends List<? extends Map<K, V>>>泛型類型的，泛型類型在java中使用ParameterizedType接口表示
6、拆解Map<String, ? extends List<? extends Map<K, V>>>后面尖括號中的參數(shù)列表，可以調(diào)用ParameterizedType接口的Type[] getActualTypeArguments()方法獲取，Map后面的尖括號中有2個(gè)參數(shù)，分別是String和? extends List<? extends Map<K, V>>
7、String是java中定義的類型，對應(yīng)java中的Class對象
8、? extends List<? extends Map<K, V>>是通配符類型的，對應(yīng)WildcardType接口，通配符指定了上邊界，上邊界是List<? extends Map<K, V>>
9、List<? extends Map<K, V>>又是一個(gè)泛型類型，泛型類型對應(yīng)ParameterizedType接口，List<? extends Map<K, V>>的尖括號中又定義了這個(gè)泛型類型的具體的類型? extends Map<K, V>
10、? extends Map<K, V>又是一個(gè)通配符類型，對應(yīng)WildcardType接口,這個(gè)通配符指定了上邊界為Map<K,V>
11、Map<K,V>又對應(yīng)泛型類型，泛型類型對應(yīng)ParameterizedType接口，調(diào)用這個(gè)接口的getActualTypeArguments()方法獲取泛型中的參數(shù)列表K和V
12、K和V是Demo10中定義的泛型變量類型，泛型變量類型對應(yīng)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 + "泛型數(shù)組類型:" + type);parseType(((GenericArrayType) type).getGenericComponentType(), ++level);} else if (type instanceof ParameterizedType) {System.out.println(whileString + "泛型類型:" + type);ParameterizedType parameterizedType = (ParameterizedType) type;System.out.println(whileString + "實(shí)際類型:" + parameterizedType.getRawType());Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();System.out.println(whileString + actualTypeArguments.length + "個(gè)泛型參數(shù),如下：");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);} }

運(yùn)行輸出：

泛型數(shù)組類型:java.util.Map<java.lang.String, ? extends java.util.List<?
extends java.util.Map<K, V>>>[][]
----泛型數(shù)組類型: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>>>
--------實(shí)際類型:interface java.util.Map
--------2個(gè)泛型參數(shù),如下：
------------普通類型: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>>
----------------實(shí)際類型:interface java.util.List
----------------1個(gè)泛型參數(shù),如下：
--------------------通配符類型:? extends java.util.Map<K, V>
--------------------通配符類型名稱:? extends java.util.Map<K, V>
--------------------上邊界列表
------------------------泛型類型:java.util.Map<K, V>
------------------------實(shí)際類型:interface java.util.Map
------------------------2個(gè)泛型參數(shù),如下：
----------------------------泛型變量類型:K
----------------------------泛型變量上邊界列表
--------------------------------普通類型:java.lang.Object
----------------------------泛型變量類型:V
----------------------------泛型變量上邊界列表
--------------------------------普通類型:java.lang.Object
--------------------下邊界列表
------------下邊界列表

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

原文地址：
https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933878&idx=1&sn=bebd543c39d02455456680ff12e3934b&chksm=88621dc8bf1594de6b50a760e4141b80da76442ba38fb93a91a3d18ecf85e7eee368f2c159d3&token=799820369&lang=zh_CN#rd

總結(jié)

以上是生活随笔為你收集整理的【转载】java中泛型使用详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。