Java中Type接口及其子类

简介

Type是Java 编程语言中所有类型的公共高级接口，和Object不同，Object是所有类的父类，即Object是Type的父类。

分类

原始类型(Class)：不仅仅包含我们平常所指的类，还包括枚举、数组、注解等；

参数化类型(ParameterizedType)：就是我们平常所用到的泛型List、Map；

数组类型(GenericArrayType)：并不是我们工作中所使用的数组String[] 、byte[]，而是带有泛型的数组，即T[] ；

基本类型(Class)：也就是我们所说的java的基本类型，即int,float,double等。

详细分类

ParameterizedType

• 含义:
  
  参数化类型，即泛型；例如：List、Map<K,V>等带有参数化的对象;
• 代码：

   /**
     *
     * ParameterizedType表示参数化类型，也就是泛型，例如List<T>、Set<T>等；
     **/
    private List<T> list=null;
    private List<T> set=null;

    @Test
    public void test() throws NoSuchFieldException {
        Field fieldList=ParameterizedTypeDemo.class.getDeclaredField("list");
        Type typeList = fieldList.getGenericType();
        //sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
        System.out.println("获取的type类型 typeList-->"+typeList.getClass().getName());
        Field fieldSet=ParameterizedTypeDemo.class.getDeclaredField("set");
        Type typeSet = fieldSet.getGenericType();
        //sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
        System.out.println("获取的type类型 typeSet-->"+typeSet.getClass().getName());
    }

    private Map<String,Integer> map=null;

    @Test
    public void tset2() throws NoSuchFieldException {
        Field declaredField = ParameterizedTypeDemo.class.getDeclaredField("map");
        Type genericType = declaredField.getGenericType();
        ParameterizedType parameterizedType=(ParameterizedType)genericType;
        Type name1 = parameterizedType.getActualTypeArguments()[0];
        //java.lang.String
        System.out.println("ParameterizedType 获取参数1泛型类全名-->"+name1.getTypeName());
        Type name2 = parameterizedType.getActualTypeArguments()[1];
        //java.lang.Integer
        System.out.println("ParameterizedType 获取参数2泛型类全名-->"+((Class)name2).getName());
        Type rawType = parameterizedType.getRawType();
        //interface java.util.Map
        System.out.println("获取声明泛型的类或者接口---》"+rawType);
    }

TypeVariable

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

private List<T> list;

    /**
     * 泛型的类型变量，指的是List<T>、Map<K,V>中的T，K，V等值，实际的Java类型是TypeVariableImpl
     * （TypeVariable的子类）；此外，还可以对类型变量加上extend限定，这样会有类型变量对应的上限；
     *
     **/
    @Test
    public void test() throws NoSuchFieldException {
        Field list = TypeVariableDemo.class.getDeclaredField("list");
        //获取该属性的实际类型
        Type genericType = list.getGenericType();
        ParameterizedType parameterizedType=(ParameterizedType)genericType;
        //获取泛型中的实际类型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
         //sun.reflect.generics.reflectiveObjects.TypeVariableImpl
        System.out.println("获取泛型中的实际类型-->"+actualTypeArguments[0].getClass().getName());
    }

    @Test
    public void test2() throws NoSuchFieldException {
       new TypeVariableTwoDemo().test();

    }

    public class TypeVariableTwoDemo<T extends Number & Serializable & Comparable,K>{

        private T t;
        private K k;

        public void test() throws NoSuchFieldException {

            Field field = TypeVariableTwoDemo.class.getDeclaredField("t");
            Type genericType = field.getGenericType();
            TypeVariable typeVariable=(TypeVariable)genericType;
            Type[] bounds = typeVariable.getBounds();
            //class java.lang.Number
            //interface java.io.Serializable
            //interface java.lang.Comparable
            Arrays.stream(bounds).forEach(s-> System.out.println("获取类型变量的上界-->"+s));

            Field field2 = TypeVariableTwoDemo.class.getDeclaredField("k");
            Type genericType2 = field2.getGenericType();
            TypeVariable typeVariable2=(TypeVariable)genericType2;
            Type[] bounds2 = typeVariable2.getBounds();
            //class java.lang.Object
            Arrays.stream(bounds2).forEach(s-> System.out.println("获取类型变量的上界-->"+s));
            //class com.yxkj.other.modular.reflection.type.TypeVariableDemo$TypeVariableTwoDemo
            System.out.println("获取声明该类型变量实体-->"+typeVariable2.getGenericDeclaration());
            //K
            System.out.println("获取声明该类型变量实体-->"+typeVariable2.getName());
        }
    }

GenericArrayType

• 含义:
  
  泛型数组类型，用来描述ParameterizedType、TypeVariable类型的数组；即List[] 、T[]等；
• 代码：

private T[] t;

    private List<String>[] listArray;

    /**
     *  泛型数组类型，例如List<String>[] 、T[]等；
     *
     **/
    @Test
    public void test() throws NoSuchFieldException {
        Field t = GenericArraytypeDemo.class.getDeclaredField("t");
        Type genericType = t.getGenericType();
        //sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
        System.out.println("获取Type的实际类型-->"+genericType.getClass().getName());
    }

    @Test
    public void test2() throws NoSuchFieldException {
        Field t = GenericArraytypeDemo.class.getDeclaredField("listArray");
        Type genericType = t.getGenericType();
        GenericArrayType genericType1 = (GenericArrayType) genericType;
        Type genericComponentType = genericType1.getGenericComponentType();
        //java.util.List<java.lang.String>
        System.out.println("获取listArray的实际类型-->"+genericComponentType);
    }

Class

• 含义:
  
  上三者不同，Class是Type的一个实现类，属于原始类型，是Java反射的基础，对Java类的抽象；

在程序运行期间，每一个类都对应一个Class对象，这个对象包含了类的修饰符、方法，属性、构造等信息，所以我们可以对这个Class对象进行相应的操作，这就是Java的反射；

*代码:

private ClassDemo classDemo;

    /**
     *
     * 在Java中，每个.class文件在程序运行期间，都对应着一个Class对象，
     * 这个对象保存有这个类的全部信息；因此，Class对象也称之为Java反射的基础
     *
     **/
    @Test
    public void test() throws NoSuchFieldException {
        Field field = ClassDemo.class.getDeclaredField("classDemo");
        Type genericType = field.getGenericType();
        //class com.yxkj.other.modular.reflection.type.ClassDemo
        System.out.println("获取Type原始类型-->"+genericType);
    }

WildcardType

• 含义:
  
  泛型表达式（或者通配符表达式），即？ extend Number、？ super Integer这样的表达式；WildcardType虽然是Type的子接口，但却不是Java类型中的一种；
  
  *代码:

    private List<? extends Number> listNum;

    private List<? super String> listStr;

    /**
     *
     *  ？---通配符表达式，表示通配符泛型，但是WildcardType并不属于Java-Type中的一钟；
     *  例如：List<? extends Number> 和 List<? super Integer>；
     *
     **/
    @Test
    public void test() throws NoSuchFieldException {
        Field declaredField = WildcardTypeDemo.class.getDeclaredField("listNum");
        Type genericType = declaredField.getGenericType();
        ParameterizedType parameterizedType=(ParameterizedType)genericType;
        //获取泛型中的实际类型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        //class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
        System.out.println("获取泛型中的实际类型-->"+actualTypeArguments[0].getClass());
        WildcardType wildcardType= (WildcardType)actualTypeArguments[0];

        Type[] upperBounds = wildcardType.getUpperBounds();
        System.out.println("获取泛型变量的上边界-->"+upperBounds[0]);

        Field declaredFieldlowerBounds = WildcardTypeDemo.class.getDeclaredField("listStr");
        Type genericTypelowerBounds = declaredFieldlowerBounds.getGenericType();
        ParameterizedType parameterizedTypelowerBounds=(ParameterizedType)genericTypelowerBounds;
        //获取泛型中的实际类型
        Type[] actualTypeArgumentslowerBounds = parameterizedTypelowerBounds.getActualTypeArguments();
        WildcardType wildcardTypelowerBounds= (WildcardType)actualTypeArgumentslowerBounds[0];

        Type[] lowerBounds = wildcardTypelowerBounds.getLowerBounds();

        System.out.println("获取泛型变量的下边界-->"+lowerBounds[0]);

    }

Gitee案例地址

https://gitee.com/zhuayng/foundation-study/tree/develop/JavaBasis/Other/src/main/java/com/yxkj/other/modular/reflection/type

参考

https://www.cnblogs.com/linghu-java/p/8067886.html