Type是Java 编程语言中所有类型的公共高级接口,也就是说Java中所有的类型都实现了这个接口,其意义表示Java所有类型,这里所谓的类型是从Java整个语言角度来看的,比如原始类型、参数化类型(泛型)、类型变量及其数组等,可以理解为,Class(类)是Java对现实对象的抽象,而Type是对Java语言对象的抽象。
Type体系中类型的包括:原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class);
原始类型,不仅仅包含我们平常所指的类,还包括枚举、数组、注解等;
参数化类型,就是我们平常所用到的泛型List、Map<E,M>;
数组类型,带有泛型的数组,即T[] ;
基本类型,也Java的基本类型,即int,float,double等
Type
Type本身只是一个简单的接口,只有一个default方法,基本上只是一个抽象的概念.
package java.lang.reflect;
/**
* Type is the common superinterface for all types in the Java
* programming language. These include raw types, parameterized types,
* array types, type variables and primitive types.
*
* @since 1.5
*/
public interface Type {
/**
* Returns a string describing this type, including information
* about any type parameters.
*
* @implSpec The default implementation calls {@code toString}.
*
* @return a string describing this type
* @since 1.8
*/
default String getTypeName() {
return toString();
}
}
Type的子类
Type的直接子接口
1.ParameterizedType: 表示一种参数化的类型,比如Collection(集合),即普通的泛型。
2.TypeVariable:是各种类型变量的公共父接口,就是泛型里面的里的T、E。
3.GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型,比如List<>[],T[]这种。
4.WildcardType:代表一种通配符类型表达式,类似? super T这样的通配符表达式。(这个不讲)
Type的直接子类
Type的直接子类只有一个,也就是Class,代表着类型中的原始类型以及基本类型。
ParameterizedType
参数化类型,即泛型,类似List、Map<String, Integer>等带有类型参数的类型
ParameterizedType接口源码
public interface ParameterizedType extends Type {
//返回<>中的实际类型,如XX<Integer>
Type[] getActualTypeArguments();
//返回<>前的实际类型,如List<XX>
Type getRawType();
//返回泛型的所有者即内部类的“父类”,如果没有则返回null
//如Map.Entry<T,M>,就会返回Map,因为Map是Map.Entry<T,M>的所有者
Type getOwnerType();
}
getActualTypeArguments
public List<T> list = null;
public Map<String, Integer> map = null;
public static void main(String[] args) throws Exception {
//通过反射获取list属性
Field field = Type01.class.getDeclaredField("list");
//获取该属性的泛型类型
Type listType = field.getGenericType();
/*
*类型为:sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl,从中可以大概知道,泛型是getActualTypeArguments实现类
*/
System.out.println(listType.getClass().getName());
//通过反射获取属性map
Field map = Type01.class.getDeclaredField("map");
//获取泛型的类型
Type typeMap = map.getGenericType();
System.out.println(typeMap);//java.util.Map<java.lang.String, java.lang.Integer>
//将Type类型强转为其子类ParameterizedType
ParameterizedType pMap = (ParameterizedType) typeMap;
//获取泛型中的参数类型,即map<String, Integer>中的String,Integer,实际上返回的是TypeVariable类型
Type[] types = pMap.getActualTypeArguments();
System.out.println(types[0]);//class java.lang.String
System.out.println(types[1]);//class java.lang.Integer
}
注意的是: 无论<>中有几层<>嵌套,这个方法仅仅脱去最外层的<>,之后剩下的内容就作为这个方法的返回值,如List<Map<M,E>>,就会返回Map<M,E>.
getRawType
获取声明泛型的类或者接口,也就是泛型中<>前面的那个值
//通过反射获取属性map
Field map = Type01.class.getDeclaredField("map");
//获取泛型的类型
Type typeMap = map.getGenericType();
//将Type类型强转为其子类ParameterizedType
ParameterizedType pMap = (ParameterizedType) typeMap;
//获取泛型<>前的类型
Type rawType = pMap.getRawType();
System.out.println(rawType);//interface java.util.Map
GenericArrayType
泛型数组,表示上面两种的数组类型,即形如:A[],T[][]类型。GenericArrayType接口源码
public interface GenericArrayType extends Type {
//返回泛型数组的元素类型,如List<T>[] 返回 List<T>
Type getGenericComponentType();
}
getGenericComponentType
public List<T>[] lists = null;
public List<String>[] stringLists = null;
public static void main(String[] args) throws Exception {
Field lists = Type01.class.getDeclaredField("stringLists");
Type listType = lists.getGenericType();
//泛型的类型 sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
System.out.println(listType.getClass().getName());
GenericArrayType genericArrayType = (GenericArrayType) listType;
//泛型数组中元素的类型 java.util.List<java.lang.String>
Type type = genericArrayType.getGenericComponentType();
System.out.println(type);
}
TypeVariable
TypeVariable,类型变量,描述类型,表示泛指任意或相关一类类型,也可以说狭义上的泛型(泛指某一类类型),一般用大写字母作为变量,比如K、V、E等。在这需要强调的是,TypeVariable代表着泛型中的变量,而ParameterizedType则代表整个泛型TypeVariable接口源码
public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
//获得泛型的上限,若未明确声明上边界则默认为Object
Type[] getBounds();
//获得泛型的上限,若未明确声明上边界则默认为Object
D getGenericDeclaration();
//获得类型变量在源码中定义的名称
String getName();
}
public List<T> list = null;
public static void main(String[] args) throws Exception {
//TypeVariable
//通过反射获取list属性
Field field = Type01.class.getDeclaredField("list");
//获取该属性的泛型类型
Type listType = field.getGenericType();
ParameterizedType parameterizedTypeList = (ParameterizedType) listType;
//获取泛型中变量的实际类型
Type[] types = parameterizedTypeList.getActualTypeArguments();
//sun.reflect.generics.reflectiveObjects.TypeVariableImpl
System.out.println(types[0].getClass().getName());
}
---------------------------------------未完待续-----------------------------------------------