泛型类型Type的详解
钮出野
Type
打开java api 文档可以Type是一个空接口
Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。讲的就是他的几个直接子类
大概意思就是：Type是所有类型的公共接口（父接口），其意义表示Java所有类型，这里所谓的类型是从Java整个语言角度来看的，比如原始类型、参数化类型（泛型）、类型变量及其数组等。
Type跟class的区别：这里Class是Type的一种类型，而像数组、枚举等“类型”是相对于Class来说。
所有已知子接口：GenericArrayType, ParameterizedType, TypeVariable, WildcardType
- 1.ParameterizedType： 表示一种参数化的类型，比如 Collection，即普通的泛型。
- 2.TypeVariable：是各种类型变量的公共父接口，就是泛型里面的类似T、E。
- 3.GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型，比如List<>[]，T[]这种。
- 4.WildcardType：代表一种通配符类型表达式，类似? super T这样的通配符表达式。
ParameterizedType
参数化类型，即泛型，类似List、Map
public interface ParameterizedType extends Type {
//1.获得<>中实际类型
Type[] getActualTypeArguments();
//2.获得<>前面实际类型
Type getRawType();
//3.如果这个类型是某个类型所属，获得这个所有者类型，否则返回null
Type getOwnerType();
}分别举例说明：
getActualTypeArguments
获得参数化类型中<>里的类型参数的类型，因为可能有多个类型参数，例如Map
1. List<ArrayList> a1;//这里返回的是，ArrayList，Class类型
2. List<ArrayList<String>> a2;//这里返回的是ArrayList<String>，ParameterizedType类型
3. List<T> a3;//返回的是T，TypeVariable类型
4. List<? extends Number> a4; //返回的是WildcardType类型
5. <泛型数组，描述的是形如：A<T>[]或T[]类型。> a5;//GenericArrayType getRawType
返回最外层<>前面那个类型，即Map
Method method = new Demo().getClass().getMethod("method",Map.Entry.class);
Type[] types = method.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType)types[0];
//返回所有者类型
System.out.println(getRawType());
//打印结果是interface java.util.Map
}
class Demo{
public static <K,V> void method(Map<K,V> mapEntry){}
}getOwnerType
获得这个类型的所有者的类型
Method method = new Demo().getClass().getMethod("method",Map.Entry.class);
Type[] types = method.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType)types[0];
//返回所有者类型
System.out.println(pType.getOwnerType());
//打印结果是interface java.util.Map
}
class Demo{
public static <T,U> void method(Map.Entry<T,U> mapEntry){}
}
TypeVariable
类型变量，如参数化类型中的E、K等类型变量，表示泛指任何类，如果加上extends/super限定，则就会有相应的上限、下限。
源码：
public interface TypeVariable<D extends GenericDeclaration> extends Type {
//获得泛型的上限，若未明确声明上边界则默认为Object
Type[] getBounds();
//获取声明该类型变量实体(即获得类、方法或构造器名)
D getGenericDeclaration();
//获得名称，即K、V、E之类名称
String getName();
}getGenericDeclaration
获得声明（定义）这个类型变量的类型及名称
Constructor constructor=Demo.getClass().getConstructor(String.class);
TypeVariable typeVariable = constructor.getTypeParameters()[0];
System.out.println(typeVariable.getGenericDeclaration());
//打印出com.xxx.xxx.Demo()
class Demo<T>{
public Demo(T name){}getBounds
获得该类型变量的上限（上边界），若无显式定义（extends），默认为Object，类型变量的上限可能不止一个，因为可以用&符号限定多个（这其中有且只能有一个为类或抽象类，且必须放在extends后的第一个，即若有多个上边界，则第一个&后必为接口）
class A<K extends classA & interfaceB, V>{
K key;
V value;
}
Type[] types = A.class.getTypeParameters();
for(Type type : types){
TypeVariable t = (TypeVariable)type;
System.out.println(t.getGenericDeclaration());
int size = t.getBounds().length;
System.out.println(t.getBounds()[size - 1]);
System.out.println(t.getName() + "\n-------------分割线-------------");
}
//输出结果
class com.xxx.xxx.A
interface com.fcc.test.interfaceB
K
-------------分割线-------------
class com.xxx.xxx.A
class java.lang.Object
V
-------------分割线-------------
getName
获得这个类型变量在声明（定义）时候的名称
Constructor constructor=Demo.getClass().getConstructor(String.class);
TypeVariable typeVariable = constructor.getTypeParameters()[0];
String name=typeVariable.getName();
//打印出name="name";
class Demo<T>{
public Demo(T name){}GenericArrayType
泛型数组，表示上面两种的数组类型，即形如：A[]，T[][]类型。
源码：
public interface GenericArrayType extends Type {
//获得这个数组元素类型，即获得：A<T>（A<T>[]）或T（T[]）
Type getGenericComponentType();
}getGenericComponentType
GenericArrayType，泛型数组，描述的是ParameterizedType类型以及TypeVariable类型数组，即形如：classA[][]、T[]等，是Type的子接口。
classA<K>[][] key;
Type type = Demo.class.getDeclaredField("key").getGenericType(); System.out.println(((GenericArrayType)type).getGenericComponentType());
//输出结果
//com.xxx.xxx.classA<K>[]WildcardType
通配符表达式，或泛型表达式，它虽然是Type的一个子接口，但并不是Java类型中的一种，表示的仅仅是类似 ? extends T、? super K这样的通配符表达式。
源码：
public interface WildcardType extends Type {
//获得泛型表达式上界（上限）
Type[] getUpperBounds();
//获得泛型表达式下界（下限）
Type[] getLowerBounds();
}getUpperBounds()
getLowerBounds()
class Demo{
public void test(List<? extends Number> a, List<? super Number> b) {
}
Method method=Demo.getClass.getMethod("test",List.class,List.class);
Type[] types = method.getGenericParameterTypes();
for(Type type : types){
Type[] actualTypeArgument =
((ParameterizedType)type).getActualTypeArguments();
for(Type t : actualTypeArgument){
WildcardType wildcardType =
(WildcardType) t;
lowerBounds =wildcardType.getLowerBounds();
upperBounds = wildcardType.getUpperBounds();
}
}
}
输出结果：
[class java.lang.Number]
看明白这些你就可以随心所欲的解析你的泛型，特别是在自己的网络请求中使用Gosn或者FastJson解析带有泛型对象
//一般的服务器都会返回这样的数据格式
class Result<T>{
private int code;
private String msg;
private T data
}
//根据你的实际需求获取对应的type，就可以得到泛型
T data = gson.fromJson(jsonString, type);
类似资料：