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