Type 是Java 编程语言中所有类型的公共高级接口（官方解释），也就是Java 中所有类型的”爹“。其中”所有类型“的描述尤为指的关注。它并不是我们平常工作中经常使用的int、String、List、Map等数据类型，而是从Java语言角度磊说，对基本类型、引用类型向上的抽象

Type 体系中的类型

Type 体系中类型的包括

• 原始类型（Class）：不仅仅包括我们平常所指的类，还包括枚举、数组、注解等
• 参数化类型（ParameterizedType）：就是我们平常所用到的泛型List、Map
• 泛型数组类型（GenericArrayType）：并不是我们平常所使用的数组String[] 、byte[]。而是带有泛型的数组，即 T[]
• 类型变量（TypeVariable）：是各种类型变量的公共父接口，就是泛型里面的类似T、E。 在这需要强调的是，TypeVariable代表着泛型中的变量，而ParameterizedType则代表整个泛型；
• 基本类型（Class）：也就是我们所说的java 基本类型，即int、float、double等

Type类几乎在各种框架中都能看到，尤其是涉及代理，反射的业务。理解好Type类也会对今后框架封装，源码解读有很大好处

Type 与子类，子接口的关系

Class

当需要描述的类型是：

• 普通的java类（比如String，Integer，Method等等）
• 数组
• 自定义类（比如我们自己定义的TestReflect类）
• java基本类型（比如int，float等）
• 可能还有其他的类

那么java会选择Class来作为这个Type的实现类，我们甚至可以直接把这个Type强行转换类型为Class。
这些类基本都有一个特点：基本和泛型无关，其他4种Type的类型，基本都是泛型的各种形态

Type

public interface Type {@RecentlyNonNulldefault String getTypeName() {throw new RuntimeException("Stub!");}
}

ParameterizedType （参数化类型）

ParameterizedType 是参数化类型，即泛型，类似List、Map<Integer, String>、List<? extends Number>带有类型参数的类型，也可以是自定义的，再调用getRawType()与getActualTypeArguments()两个方法，就可以得到声明此参数化类型的类(java.lang.Comparable)和实际的类型参数数组([? super T])，而这个? super T又是一个WildcardType类型。

 // 获取泛型的类型,比如 Map<Integer,String> 获取的是 Integer和StringType[] getActualTypeArguments();// 获取<> 前面的类型,比如 Map<Integer,String> 获取的是MapType getRawType();// 如果这个类型是某个类型所属，则获取这个所有者的类型，否则返回null,比如Map.Entry<Sting,String>，会返回MapType getOwnerType();//举例//参数，List<String>[] p3public class TestReflect {public static void test(List<TestReflect> p1,Map<String, TestReflect> p2) {}}Method[] methods = TestReflect.class.getMethods();Method method=methods[i].eques("test");Type[] types=method.getGenericParameterTypes();//第一个参数 List<TestReflect> p1Type type3=types[0];Type[] parameterizedType1=((ParameterizedType)type1).getActualTypeArguments();Class parameterizedType1_0=(Class)parameterizedType1[0];System.out.println("获取泛型的类型 :"+parameterizedType1_0.getName());//【打印log】 获取泛型的类型 :com.wf.javatype.TestReflect//第二个参数，Map<String,TestReflect> p2Type type2=types[2];Type[] parameterizedType2=((ParameterizedType)type2).getActualTypeArguments();Class parameterizedType2_0=(Class)parameterizedType2[0];System.out.println("获取泛型的类型 1:"+parameterizedType2_0.getName());Class parameterizedType2_1=(Class)parameterizedType2[1];System.out.println("获取泛型的类型 2:"+parameterizedType2_1.getName());//【打印log】//获取泛型的类型 1:java.lang.String//获取泛型的类型 2:com.wf.javatype.TestReflect

GenericArrayType （泛型数组类型）

泛型数组类型，用来描述ParameterizedType、TypeVariable类型的数组；即List[] 、T[]等

public interface GenericArrayType extends Type {/***  获取泛型数组中元素的类型，要注意的是：无论从左向右有几个[]并列，这个方法仅仅脱去最右边的[]之后剩下的内容就作为这个方法的返回值。*/Type getGenericComponentType();//举例1//参数，List<String>[] p3public class TestReflect {public static void test(List<String>[] p3,Map<String,TestReflect>[] p4) {}}Method[] methods = TestReflect.class.getMethods();Method method=methods[i].eques("test");Type[] types=method.getGenericParameterTypes();Type type3=types[0];Type genericArrayType3=((GenericArrayType)type3).getGenericComponentType();System.out.println("类型 :"+genericArrayType3.getTypeName());//【打印log】 类型 :java.util.List<java.lang.String>//举例2Type type4=types[1];Type genericArrayType4=((GenericArrayType)type4).getGenericComponentType();ParameterizedType parameterizedType4=(ParameterizedType)genericArrayType4;System.out.println("获取泛型类型 :"+parameterizedType4.getTypeName());//【打印log】获取泛型类型 :java.util.Map<java.lang.String, com.wf.javatype.TestReflect>Type[] parameterizedType4Arr=parameterizedType4.getActualTypeArguments();Class class4_0=(Class)parameterizedType4Arr[0];System.out.println("获取泛型类型 1:"+class4_0.getName());//【打印log】获取泛型类型 1:java.lang.StringClass class4_1=(Class)parameterizedType4Arr[1];System.out.println("获取泛型类型 2:"+class4_1.getName());//【打印log】获取泛型类型 2:com.wf.javatype.TestReflect
}

TypeVariable (类型变量类型)

类型变量，即泛型中的变量；例如：T、K、V等变量，可以表示任何类；在这需要强调的是，TypeVariable代表着泛型中的变量，而ParameterizedType则代表整个泛型；

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {// 获取泛型的上限，无显示定义(extends),默认为ObjectType[] getBounds();// 获取声明改类型变量实体(即获取类，方法或构造器名)D getGenericDeclaration();// 获取名称，即K、V、E之类名称String getName();// AnnotatedType[] getAnnotatedBounds();

认识TypeVariable之前,我们先来看另一个接口 GenericDecalaration;
GenericDeclaration 有三个直接子类 Class、Construtor、Method、Executable也就是说只能在这几种对象上进行范型变量的声明（定义）。

GenericDeclaration

//1.在类（Class）上声明（定义）类型变量
class A<T>{T a;
}//之后这里可用任意类型替换T，例如
A<String> as = new A<String>();
//是否看着有点像集合？不错，集合就是泛型的一个典型运用//2.在方法上声明（定义,方法上，类型变量声明（定义）不是在参数里边，而且必须在返回值之前,static等修饰后
public <E> void test(E e){}//3.声明（定义）在构造器上
public <K> A(K k){}//4. 第四种没有使用过，有会的大佬可以指点我一下

【注意】：类型变量声明（定义）的时候不能有下限（super）,否则编译器报错。为什么T extend classA 表示泛型有上限classA 可以，因为每一个传进来的类型必定是classA(具有classA 的一切属性和方法) ，但若是T super classA，传进来的类型不一定具有classA的属性和方法，当然就不使用与泛型

【extends 和 super的区别】

关键字说明? 通配符类型
<? extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类
<? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object
看了这个我是不太明白，换成白话是这个意思：
List<? extends T> 是说 这个list放的是T或者T的子类型的对象，但是不能确定具体是什么类型，所以可以get（），不能add（）（可以add null值）List<? super T> 是说这个list放的是至少是T类型的对象，所以我可以add T或者T的子类型，但是get得到的类型不确定，所以不能获取

WildcardType (泛型表达式或者通配符表达式)

当需要描述的类型是泛型类，而且泛型类中的泛型被定义为(? extends xxx)或者(? super xxx)这种类型，比如List<? extends TestReflect>，这个类型首先将由ParameterizedType实现，当调用ParameterizedType的getActualTypeArguments()方法后得到的Type就由WildcardType实现。

public interface WildcardType extends Type {//得到的是类型的上边界的Type数组，实际上就是类型的直接父类，也就是extends后面的类型。//显然在当前java的设定中，这个数组只可能有一个元素，因为java现在只能extends一个类。如果实在没写extends，那他的直接父类就是Object@RecentlyNonNullType[] getUpperBounds();//得到的是类型的下边界的Type数组，有super关键字时可能会用到，经测试不会得到类型的子类，//而是只得到super关键字后面的类型，如果没写super关键字，则返回空数组。@RecentlyNonNullType[] getLowerBounds();
}

示例

public class TestReflect {public static void test(TestReflect p0,List<TestReflect> p1,Map<String, TestReflect> p2,List<String>[] p3,Map<String, TestReflect>[] p4,List<? extends TestReflect> p5,Map<? extends TestReflect, ? super TestReflect> p6) {}
}@Test
public  void main() {//获取 TestReflect 类的所有方法Method[] methods = TestReflect.class.getMethods();for (int i = 0; i < methods.length; i++) {Method method=methods[i];if(method.getName().equals("test")){System.out.println("TestReflect 的 方法: "+method.getName());Type[] types=method.getGenericParameterTypes();//第一个参数，TestReflect p0Class type0=(Class)types[0];//【打印log】 type0 :com.wf.javatype.TestReflectSystem.out.println("type0 :"+type0.getName());//第二个参数，List<TestReflect> p1//获取泛型的类型Type type1=types[1];Type[] parameterizedType1=((ParameterizedType)type1).getActualTypeArguments();Class parameterizedType1_0=(Class)parameterizedType1[0];//【打印log】获取泛型的类型 :com.wf.javatype.TestReflectSystem.out.println("获取泛型的类型 :"+parameterizedType1_0.getName());//第三个参数，Map<String,TestReflect> p2Type type2=types[2];Type[] parameterizedType2=((ParameterizedType)type2).getActualTypeArguments();Class parameterizedType2_0=(Class)parameterizedType2[0];//【打印log】 获取泛型的类型 1:java.lang.StringSystem.out.println("获取泛型的类型 1:"+parameterizedType2_0.getName());Class parameterizedType2_1=(Class)parameterizedType2[1];//【打印log】获取泛型的类型 2:com.wf.javatype.TestReflectSystem.out.println("获取泛型的类型 2:"+parameterizedType2_1.getName());}}
}