1. Type的理解

Type是对java数据类型的分类抽象,通过下面图片可以看到，对于泛型的类型取值是最为广泛的,通常是用于动态反射取类型的时候会用到下面的这些方法

type体系

我们通过举例来认识一下这些类型

2. Type

首先所有的数据类型的类型都是Type,Class就是继承自Type的,下面很简单的一段代码来表达,应该没有任何理解上的问题

public class TypeTest {

    public static void main(String[] args) {

        Type type = TypeTest.class;
        System.out.println(type);
    }
}

3. ParameterizedType

image.png

比如ArrayList<String>

3.1 getActualTypeArguments返回是一个数组,getActualTypeArguments[0]就是String类型
3.2 ArrayList就是getRawType
3.3 getOwnerType属于nested类型,使用场景比较少,不深究

看一下代码

       @Test
    public void test1()
    {
        Foo<Integer> foo = new Foo<Integer>(){};
        Type mySuperClass = foo.getClass().getGenericSuperclass();
        Type type = ((ParameterizedType)mySuperClass).getActualTypeArguments()[0];
        System.out.println(type);
    }

输出结果:
class java.lang.Integer

4. TypeVariable

代表泛型中的变量,比如下面的T就是TypeVariable类型

public class TypeVariableTest<T extends Number & Serializable> {
    private T t;
}

4.1 t的getBounds就是Number和Serializable
组,getActualTypeArguments[0]就是String类型
4.2 getGenericDeclaration就是TypeVariableTest
4.3 getName就是变量泛型名称T

测试代码:

    @Test
    public void testGetBounds() throws  NoSuchFieldException
    {
        Field fieldT=TypeVariableTest.class.getDeclaredField("t");
        TypeVariable typeVariable=(TypeVariable)fieldT.getGenericType();

        Type[] types=typeVariable.getBounds();

        for (Type type:types)
        {
            System.out.println(type);
        }
        System.out.println(typeVariable.getName());

        System.out.println(typeVariable.getGenericDeclaration());
    }

结果输出:

class java.lang.Number
interface java.io.Serializable
T
class demo.base.reflect.TypeVariableTest

5. WildcardType

这里要理解泛型上界和下界的概念,可以参考此文:
http://blog.csdn.net/jeffleo/article/details/52250948

    static class Fruit{}
    static class Apple extends Fruit{}
    static class Apple1 extends Apple{}
    static class Orange extends Fruit{}

    List<? extends Fruit> list1;
    List<? super Apple> list2;

List<? extends Fruit>定义了上界,?类型是Fruit的子类
List<? super Apple>定义了下界,?类型是Apple的父类

遵循PECS原则

如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
如果既要存又要取，那么就不要使用任何通配符。

通常会在传参的时候会用到该方式,可以视作为一种约束条件

测试代码:

public class WildcardTypeTest {

    private List<? extends String> listStr;

    private List<? super String> b;

    public static void testGetBounds(String field) throws  NoSuchFieldException {

        System.out.println(field);
        Field fieldNum = WildcardTypeTest.class.getDeclaredField(field);
        Type typeNum = fieldNum.getGenericType();
        ParameterizedType parameterizedTypeTypeNum = (ParameterizedType) typeNum;
        Type[] typesNum = parameterizedTypeTypeNum.getActualTypeArguments();

        WildcardType wildcardType = (WildcardType) typesNum[0];
        {
            Type[] types = wildcardType.getUpperBounds();
            for (Type type : types) {
                System.out.println(type);
            }

            types = wildcardType.getLowerBounds();
            for (Type type : types) {
                System.out.println(type);
            }
        }

    }

    public static void testGetUpperBounds() throws  NoSuchFieldException
    {
        testGetBounds("listNum");
        testGetBounds("b");
    }

    public static void main(String[] args) throws NoSuchFieldException {
        testGetUpperBounds();
    }
}

输出结果:

listNum
class java.lang.Number
b
class java.lang.Object
class java.lang.String

6. GenericArrayType

public class GenericArrayTypeBean<T> {
    // 属于 GenericArrayType
    List<String>[] pTypeArray;
    // 属于 GenericArrayType
    T[] vTypeArray;
    // 不属于 GenericArrayType
    List<String> list;
    // 不属于 GenericArrayType
    String[] strings;
}

如pTypeArray的getGenericComponentType就是List<String>

参考文章:
https://www.jianshu.com/p/7649f86614d3

对java-Type的理解