简介
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]);
}