Java中Type类

Java中Type

Type时Java语言中所有类型的公共高级接口，也就是Java中所有类型的“爹”；其中所有的类型并不是我们经常使用的int，String等类型，而是对基本数据类型，引用类型向上的抽象。

Type体系中的类型包括：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class);

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

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

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

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

ParameterizedType

分别为获得实际的类型，获得前面的类型，这个类型是否某个类型所属，获得这个所有者的类型，否则返回null

参数泛型化，即泛型；例如List等带有参数化的对象

package com.zss.test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Set;

/**
 * @author zss
 */
public class Test<T> implements Type {
    private List<T> list=null;
    private Set<T> set=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field field= Test.class.getDeclaredField("list");
        //获取该属性的泛型类型
        Type typeList= field.getGenericType();
        System.out.println(typeList.getClass().getName());
        
        Field field1=Test.class.getDeclaredField("set");
        Type typeSet=field1.getGenericType();
        System.out.println(typeSet.getClass().getName());
    }

}

getActualTypeArguments

当我们包含有多个泛型的时候，会返回一个数组用来保存这些数组

public class Test<T> implements Type {
       private Map<String,Integer> map=null;
    public static void main(String[] args) throws NoSuchFieldException {

        Field fieldMap=Test.class.getDeclaredField("map");

        Type typeMap= fieldMap.getGenericType();
        ParameterizedType parameterizedType=(ParameterizedType) typeMap;

        Type []types= parameterizedType.getActualTypeArguments();
        System.out.println(types[0].getClass().getName());
        System.out.println(types[1]);

    }

}

getRawType

获取声明泛型或者接口，就是泛型中<>前面的值

Type types= parameterizedType.getRawType();
System.out.println(types);

getOwnerType

获得内部类的拥有者

public class Test<T> implements Type {
       private Map.Entry<String,Integer> map=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field fieldMap=Test.class.getDeclaredField("map");
        Type typeMap= fieldMap.getGenericType();
        ParameterizedType parameterizedType=(ParameterizedType) typeMap;
        Type types= parameterizedType.getOwnerType();
        System.out.println(types);


    }

}

GenericArrayType

泛型数组类型List[]等

public class Test<T> implements Type {
       private Map<String,Integer> []map=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field fieldMap=Test.class.getDeclaredField("map");
        Type typeMap= fieldMap.getGenericType();

        System.out.println(typeMap);


    }

}

getGenericComponentType

返回数组中元素的Type类型，即去除数组之后的

public class Test<T> implements Type {
       private Map<String,Integer> []map=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field fieldMap=Test.class.getDeclaredField("map");
        Type typeMap= fieldMap.getGenericType();
        GenericArrayType genericArrayType=(GenericArrayType) typeMap;
        System.out.println(genericArrayType);
    }
}

TypeVariable

指List等值的概念

public class Test<T> implements Type {
       private List<String> list=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field fieldMap=Test.class.getDeclaredField("list");
        Type type=fieldMap.getGenericType();
        System.out.println(type);

        ParameterizedType parameterizedType=(ParameterizedType) type;
        System.out.println(parameterizedType);

        Type[] types=parameterizedType.getActualTypeArguments();
        System.out.println(types[0].getClass().getName());
    }
}

当然还有别的方法进行调整

在TypeVariable接口中，有3个方法，分别为getBounds()、getGenericDeclaration()、getName()；

Class

Type接口的实现类，是我们工作中常用到的一个对象；在Java中，每个.class文件在程序运行期间，都对应着一个Class对象，这个对象保存有这个类的全部信息；因此，Class对象也称之为Java反射的基础；

public class Test<T> implements Type {
       private List<String> list=null;
    public static void main(String[] args) throws NoSuchFieldException {
        Field field=Test.class.getDeclaredField("list");
        Type type=field.getGenericType();
        System.out.println(type);
    }
}

package com.zss.test;

import java.lang.reflect.*;

class Person<T,W>{

}

public class Test extends Person<Integer, Boolean> {

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {

        Test student = new Test();
        Class clazz = student.getClass();
        System.out.println(clazz);
        System.out.println("获取父类对象：" + clazz.getSuperclass());
        /**
         * getGenericSuperclass()获得带有泛型的父类
         * Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
         */
        Type type = clazz.getGenericSuperclass();
        System.out.println(type);

        //ParameterizedType参数化类型，即泛型
        ParameterizedType p = (ParameterizedType)type;
        //getActualTypeArguments获取参数化类型的数组，泛型可能有多个
        Class c1 = (Class)p.getActualTypeArguments()[0];
        System.out.println(c1);
        Class c2 = (Class)p.getActualTypeArguments()[1];
        System.out.println(c2);
    }



    }

/**
 * 运行结果：
 * 获取父类对象：class com.mycode.test.Person
 * com.mycode.test.Person<java.lang.Integer, java.lang.Boolean>
 * class java.lang.Integer
 * class java.lang.Boolean
 */