前言:坚信自己坚信的,坚持自己坚持的,永远选择相信自己。
相关文章:
1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》
2、《夯实JAVA基本之一——泛型详解(2):高级进阶》
3、《夯实JAVA基本之二 —— 反射(1):基本类周边信息获取》
4、《夯实JAVA基本之二 —— 反射(2):泛型相关周边信息获取》
5、《夯实JAVA基本之二 —— 反射(3):类内部信息获取》
在上篇中,我们简单给大家讲解了如何利用反射来获取普通类型的类的使用,今天给大家讲解下,有关如何使用反射来获取泛型中的信息。提前提个醒,本篇文章内容稍难,大家可能需要多看几篇。
这篇文章将大量用到泛型的知识,如果对泛型声明及填充不太了解的同学,请先看完《夯实JAVA基本之一 —— 泛型详解系列》
一、获取泛型超类和接口的相信信息
在这部分内容中,我们将讲述如何获取泛型的超类和接口,把上篇中遗留下来的两个函数先讲完。1、获取泛型超类相信信息
上篇中,我们讲了,要获取泛型类型的超类,要用到一个函数:- //针对泛型父类而设计
- public Type getGenericSuperclass();
- //Point泛型类的实现
- public class Point<T> {
- private T x,y;
- public T getX() {
- return x;
- }
- public void setX(T x) {
- this.x = x;
- }
- public T getY() {
- return y;
- }
- public void setY(T y) {
- this.y = y;
- }
- }
- //PointImpl类的实现
- public class PointImpl extends Point<Integer> {
- }
下面, 我们将通过反射获取PointImpl的父类的类型,以及PointImpl的填充类型
我们在没看代码之前,我们先看看结果,我们知道PointImpl的父类类型是Point,而PointImpl的填充类型应该是Integer.
然后我们再看看代码:
- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG,"填充类型为:" + parameterArgClass.getName());
- }
- //返回 Type 对象,表示声明此类型的类或接口。
- Type type1 = parameterizedType.getRawType();
- Class class22 = (Class) type1;
- Log.d(TAG,"PointImpl的父类类型为:"+class22.getName());
- }
从结果中,我们可以看到,先获得到的是PointImpl在填充父类时的类型Integer,然后获得的是PointImpl的父类类型。
下面先看如何获取当前类在填充父类时的填充类型的:
对应代码是这一块:
- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG,"填充类型为:" + parameterArgClass.getName());
- }
- }
下面我们对这块分块讲解:
(1)、获取泛型超类
- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
(2)、Type类型
我们先看看Type的源码,看他自己是怎么说的:- package java.lang.reflect;
- /**
- * Common interface implemented by all Java types.
- *
- * @since 1.5
- */
- public interface Type {
- // Empty
- }
这就有点坑爹了,再仔细查代码会出现,Class继承了这个接口:
- public final class Class<T> implements Serializable, AnnotatedElement, GenericDeclaration, Type {
- …………
- }
他就是用来标识,当前Class中所填充的类型的。意思是,当我们在填充一个泛型时,比如上面我们的:
- public class PointImpl extends Point<Integer> {
- }
为了解决这个问题,Java的开发者,在Type的基础上派生了另外几个接口,分别来保存不同的类型,他们分别是:
- ParameterizedType:这就是上面我们代码中用到的,他代表的是一个泛型类型,比如Point,它就是一个泛型类型。
我们在代码中,利用:
- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
- TypeVariable:这个代表的就是泛型变量,例如Point,这里面的T就是泛型变量,而如果我们利用一种方法获得的对象是T,那它对应的类型就是TypeVariable;(这个类型的应用后面会细讲)
- WildcardType:上面的TypeVariable对应的是泛型变量,而如果我们得到不是泛型变量,而是通配符比如:? extends Integer,那它对应的类型就是WildcardType;
- GenericArrayType:如果我们得到的是类似String[]这种数组形式的表达式,那它对应的类型就是GenericArrayType,非常值得注意的是如果type对应的是表达式是ArrayList这种的,这个type类型应该是ParameterizedType,而不是GenericArrayType,只有类似Integer[]这种的才是GenericArrayType类型。
- 虽然我们后面会对TypeVariable,WildcardType进行讲解,这里还是先对他们三个类型对应的意义先总结一下,比如我们这里的clazz.getGenericSuperclass(),得到的Type对应的是完整的泛型表达式即:Point,那它对应的类型就是ParameterizedType,如果我们得到的Type对应的表达式,仅仅是Point中用来填充泛型变量T的Integer,那这个Type对应的类型就是TypeVariable,如果我们得到的是依然是填充泛型变量T的填充类型,这而个填充类型却是通配符?,那这个Type对应的类型就是WildcardType。这一段看不大明白也没关系,后面还会再讲。
(3)、ParameterizedType
上面我们已经提到当获取的Type类型,对应的是一个完整泛型表达式的时候,比如,我们这里获取到的PointImpl.class的父类:- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
在ParameterizedType中有两个极有用的函数:
- Type[] getActualTypeArguments();
- Type getRawType();
- getActualTypeArguments():用来返回当前泛型表达式中,用来填充泛型变量的真正值的列表。像我们这里得到的Point,用来填充泛型变量T的是Integer类型,所以这里返回的Integer类型所对应的Class对象。(有关这一段,下面会补充,这里先看getRawType)
- getRawType():我们从我们上面的代码中,也可以看到,它返回的值是com.harvic.blog_reflect_2.Point,所以它的意义就是声明当前泛型表达式的类或者接口的Class对象。比如,我们这里的type对应的是Point,而声明Point这个泛型的当然是Point类型。所以返回的是Point.Class
下面我们再回过来看看getActualTypeArguments():
我们上面说到,这个函数将返回用来填充泛型变量真实参数列表。像我们这里的是Point,将返回Integer对应的Class对象。而并不是所有的每次都会返回填充类型对应的Class对象。我们知道我们在填充一个泛型时,是存在各种可能的,比如Point,Point<? extends Number>,Point<ArrayList>,Point<ArrayList<? extend Number>>,等等
虽然我们没办法穷举可能填充为哪些类型,但我们知道Type类型是用来表示填充泛型变量的类型的,而继承Type接口只有下面五个:Class,ParameterizedType,TypeVariable,WildcardType,GenericArrayType!
所以这也是Type[] getActualTypeArguments();中Type[]数组的所有可能取值!
好了,现在我们再回来看看我们的代码
- Class<?> clazz = PointImpl.class;
- Type type = clazz.getGenericSuperclass();
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG,"填充类型为:" + parameterArgClass.getName());
- }
- }
- if (type instanceof ParameterizedType) {
- …………
- }
- ParameterizedType parameterizedType = (ParameterizedType) type;
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG,"填充类型为:" + parameterArgClass.getName());
- }
然后我们将得到的Type进行强转成Class类型,所以parameterArgClass对应的值就是Integer.Class。所以我们利用parameterArgClass.getName():java.lang.Integer
(5)、getRawType()
最后,我们再来看看getRawType的用法:- Type type1 = parameterizedType.getRawType();
- Class class22 = (Class) type1;
- Log.d(TAG,"PointImpl的父类类型为:"+class22.getName());
2、获取所继承泛型接口的相关信息
上泛我们也说到,获取普通类所继承的接口使用的是Class.getInterfaces()函数,如果要获取泛型接口的对象需要用到:- //获取泛型接口的方法
- public Type[] getGenericInterfaces();
这里得到的一个Type数组,因为我们一个类可以继承多个接口,所以这里的每一个type对应的就是我们所继承的一个接口类型。
下面我们举个例子来看这个接口的用法:
首先,生成一个泛型接口:
- public interface PointInterface<T,U> {
- }
然后,我们直接使用前面的PointImpl来继承好了,就不再另写其它类了:
- public class PointImpl extends Point<Integer> implements PointInterface<String,Double> {
- }
下面我们来看如何来获取PointImpl所继承的泛型接口的信息:
- Class<?> clazz = PointImpl.class;
- Type[] types = clazz.getGenericInterfaces();
- for (Type type:types) {
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
- //返回 Type 对象,表示声明此类型的类或接口。
- Type type1 = parameterizedType.getRawType();
- Class class22 = (Class) type1;
- Log.d(TAG,"声明此接口的类型为:"+class22.getName());
- }
- }
首先,是获得PointImpl.class所继承接口的数组
- Class<?> clazz = PointImpl.class;
- Type[] types = clazz.getGenericInterfaces();
然后是利用for…each循环遍历types中的每一个元素。
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
- …………
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
所以我们将它们强转为Class类型,然后通过parameterArgClass.getName()得到它们的完整路径名。
最后通过parameterizedType.getRawType()获取声明PointInterface<String,Double>的接口类类型,虽然这里得到的是Type,但我们声明接口的是PointInterface.Class所以,也是Class类型,直接将其强转为Class即可。最后通过Class.getName()获取其完整的路径名。
- //返回 Type 对象,表示声明此类型的类或接口。
- Type type1 = parameterizedType.getRawType();
- Class class22 = (Class) type1;
- Log.d(TAG,"声明此接口的类型为:"+class22.getName());
二、Type的五种类型
上面说们说过,Type接口是用来保存当前泛型被填充的类型的,它总共有五种类型:Class,ParameterizedType,TypeVariable,WildcardType,GenericArrayType在这上面的例子中,我们用到了Class,ParameterizedType;当type所代表的表达式是一个完整泛型时,比如Point,那这个Type类型就是ParameterizedType;如果type所代表的是一个确定的类,比如Integer,String,Double等,那这个type所对应的类型就是Class;强转之后,得到的就是他们所对应的Class对象,即Integer.Class,String.Class,Double.Class等
前面我们说过,如果type对应的是一个泛型变量,即类似于T,或U这种还没有被填充的泛型变量,那它的类型就是TypeVariable;而如果type对应的是一个通配符表达式,比如? extends Num,或者仅仅是一个通配符?,类似这种有通符符的类型就是WildcardType;
而如果type对应的类型是类似于String[]的数组,那它的类型就是GenericArrayType;
下面我们就来分别看看TypeVariable、WildcardType和GenericArrayType的用法
1、TypeVariable
我们上面说了,当type代表的类型是一个泛型变量时,它的类型就是TypeVariable。TypeVariable有两个函数:- String getName();
- Type[] getBounds();
- getName:就是得到当前泛型变量的名称;
- getBounds:返回表示此类型变量上边界的 Type 对象的数组。如果没有上边界,则默认返回Object;
我们依然在PointInterface泛型接口上做文章:
- public interface PointInterface<T,U> {
- }
- public class PointGenericityImpl<T extends Number&Serializable> implements PointInterface<T,Integer> {
- }
我们再看一下如何获取信息:
- Class<?> clazz = PointGenericityImpl.class;
- Type[] types = clazz.getGenericInterfaces();
- for (Type type:types) {
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- if(parameterArgType instanceof TypeVariable){
- TypeVariable typeVariable = (TypeVariable) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + typeVariable.getName());
- //返回表示此类型变量上边界的 Type 对象的数组。
- Type[] typebounds = typeVariable.getBounds();
- for (Type bound:typebounds){
- Class<?> boundClass = (Class)bound;
- //如果不写,则默认输出Object,如果写了,则输出对应的
- Log.d(TAG, "bound为:" + boundClass.getName());
- }
- }
- if (parameterArgType instanceof Class){
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
- }
- }
- }
依然是一坨复杂得像翔一样的代码,我们逐段来分析下;
首先,获取PointGenericityImpl直接继承的的泛型接口数组
- Class<?> clazz = PointGenericityImpl.class;
- Type[] types = clazz.getGenericInterfaces();
然后我们将这个元素强转为ParameterizedType,然后利用parameterizedType.getActualTypeArguments()得到PointInterface<T,U>中T和U被填充的真实类型对应的Type数组。
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
我们知道T是一个泛型变量,所以对应的类型应该是TypeVariable
而Integer则是一个具体的类,它对应的类型应该是Class
针对T:
- if(parameterArgType instanceof TypeVariable){
- TypeVariable typeVariable = (TypeVariable) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + typeVariable.getName());
- //返回表示此类型变量上边界的 Type 对象的数组。
- Type[] typebounds = typeVariable.getBounds();
- for (Type bound:typebounds){
- Class<?> boundClass = (Class)bound;
- //如果不写,则默认输出Object,如果写了,则输出对应的
- Log.d(TAG, "bound为:" + boundClass.getName());
- }
- }
然后,利用typeVariable.getBounds()得到T的限定条件:上边界的数组。上边界的意思就是extends关键字后面的限定条件。“上”的意思就是能取到的最大父类。最大父类当然是用extends关键字来限定的。我们知道这里的T的限定条件是:<T extends Number&Serializable>,所以 Type[] typebounds = typeVariable.getBounds();所得到typebounds有两个变量,一个是Number,一个是Serializable;这两个都是具体的类型,所以我们可以直接将它们转换为Class类型,然后利用Class.getName()获取它们完整的路径名,结果如下:(有关上下边界的意义下面在讲WildcardType时会有图文讲解)
针对Integer:
再来看下代码:- Class<?> clazz = PointGenericityImpl.class;
- Type[] types = clazz.getGenericInterfaces();
- for (Type type:types) {
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //返回表示此类型实际类型参数的 Type 对象的数组
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- for (Type parameterArgType : actualTypeArguments) {
- …………
- if (parameterArgType instanceof Class){
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
- }
- }
- }
- Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
- if (parameterArgType instanceof Class){
- Class parameterArgClass = (Class) parameterArgType;
- Log.d(TAG, "此接口的填充类型为:" + parameterArgClass.getName());
- }
2、GenericArrayType
上面我们说过,当type对应的类型是类似于String[]、Integer[]等的数组时,那type的类型就是GenericArrayType;这里要特别说明的如果type对应的是类似于ArrayList、List这样的类型,那type的类型应该是ParameterizedType,而不是GenericArrayType,因为ArrayList是一个泛型表达式。所以当且仅当type对应的类型是类似于String[]、Integer[]这样的数组时,type的类型才是GenericArrayType!我们先看看GenericArrayType的函数:
- Type getGenericComponentType();
好了,下面我们就举个例子来看看GenericArrayType的用法
我们重新生成一个泛型接口PointSingleInterface:
- public interface PointSingleInterface<T> {
- }
然后生成一个类继承这个接口:
- public class PointArrayImpl implements PointSingleInterface<Integer[]> {
- }
下面我们来看看如何获取PointArrayImpl的接口信息:
- Class<?> clazz = PointArrayImpl.class;
- Type[] interfaces = clazz.getGenericInterfaces();
- for (Type type:interfaces){
- if (type instanceof ParameterizedType) {
- ParameterizedType pt = (ParameterizedType) type;
- Type[] actualArgs = pt.getActualTypeArguments();
- for (Type arg:actualArgs){
- if (arg instanceof GenericArrayType){
- GenericArrayType arrayType = (GenericArrayType)arg;
- Type comType = arrayType.getGenericComponentType();
- Class<?> typeClass = (Class)comType;
- Log.d(TAG,"数组类型为:"+typeClass.getName());
- }
- }
- }
- }
依然看起来有点复杂,我们一点点来分析:
首先,通过clazz.getGenericInterfaces()获取PointArrayImpl.class的接口对应的type列表
- Class<?> clazz = PointArrayImpl.class;
- Type[] interfaces = clazz.getGenericInterfaces();
- for (Type type:interfaces){
- if (type instanceof ParameterizedType) {
- ParameterizedType pt = (ParameterizedType) type;
- Type[] actualArgs = pt.getActualTypeArguments();
- for (Type arg:actualArgs){
- …………
- }
- }
- }
- Type[] actualArgs = pt.getActualTypeArguments()
我们知道当type对应的表达式是Integer[]时,这个type的类型就是GenericArrayType
- if (arg instanceof GenericArrayType){
- GenericArrayType arrayType = (GenericArrayType)arg;
- Type comType = arrayType.getGenericComponentType();
- Class<?> typeClass = (Class)comType;
- Log.d(TAG,"数组类型为:"+typeClass.getName());
- }
好了,到这里,我们已经讲完了三种类型,下面开始讲解最后一个也是最难的一种类型WildcardType!
3、WildcardType
(1)、概述
我们前面说过,当type所代表的表达式是类型通配符相关的表达式时,比如<? extends Integer>,<? super String>,或者<?>等,这个type的类型就是WildcardType!我们先来看看WildcardType的函数:
- //获取上边界对象列表
- Type[] getUpperBounds();
- //获取下边界对象列表
- Type[] getLowerBounds();
- getUpperBounds:获取上边界对象列表,上边界就是使用extends关键定所做的的限定,如果没有默认是Object;
- getLowerBounds:获取下边界对象列表,下边界是指使用super关键字所做的限定,如果没有,则为Null
<? extends Integer>:这个通配符的上边界就是Integer.Class,下边界就是null
<? super String>:这个通配符的下边界是String,上边界就是Object;
有关上下边界,大家可能很不好记,我画个图来给大家解释下,上下边界的含义:
看到这个类继承图,大家应该很容易就明白了,类继承图中,根结点始终是在祖先类,而且在继承图的上方,所以上方的就是上界,而子类是在下方,下方的就是下界。
而表现在代码上,上界是继承的关系,所以是<? extends Object>,而下界的则是<? super Double>
(2)、有关通配符的使用范围
我们在 《夯实JAVA基本之一——泛型详解(2)》讲过,通配符只是泛型变量的填充类型的一种,不能做为泛型变量使用。在 《夯实JAVA基本之一——泛型详解(2)》中我们多次强调:通配符?只能出现在Box<?> box;中,其它位置都是不对的。
即只能出现在生成泛型实例时使用,其它位置都是不可以的。
尤其像下面这两个,直接用来填充类中的泛型变量:
但下面这样却是允许的:
因为,这里的通配符Comparable<? extends Number>,只有来生成Comparable对象的,所以是允许使用的!大家一定要注意,通配符只能用来填充泛型类来生成对象。其它用途一概是错误的!
(3)、举个例子
同样,我们使用上面的PointSingleInterface泛型接口:- public interface PointSingleInterface<T> {
- }
- public class PointWildcardImpl implements PointSingleInterface<Comparable<? extends Number>> {
- }
- Class<?> clazz = PointWildcardImpl.class;
- //此时的type对应PointSingleInterface<Comparable<? extends Number>>
- Type[] types = clazz.getGenericInterfaces();
- for (Type type:types) {
- if (type instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) type;
- //得到填充PointSingleInterface的具体参数,即:Comparable<? extends Number>,仍然是一个ParameterizedType
- Type[] actualTypes = parameterizedType.getActualTypeArguments();
- for (Type actualType : actualTypes) {
- if (actualType instanceof ParameterizedType) {
- ParameterizedType ComparableType = (ParameterizedType) actualType;
- //对Comparable<? extends Number>再取填充参数,得到的type对应<? extends Number>,这个就是WildcardType了
- Type[] compareArgs = ComparableType.getActualTypeArguments();
- for (Type Arg:compareArgs){
- if(Arg instanceof WildcardType){
- //将得到的对应WildcardType的type强转为WildcardType的变量
- WildcardType wt = (WildcardType) Arg;
- //利用getLowerBounds得到下界,即派生自Super的限定,如果没有派生自super则为null
- Type[] lowerBounds = wt.getLowerBounds();
- for (Type bound:lowerBounds){
- Class<?> boundClass = (Class)bound;
- Log.d(TAG, "lowerBound为:" + boundClass.getName());
- }
- //通过getUpperBounds得到上界,即派生自extends的限定,如果没有,默认是Object
- Type[] upperBounds = wt.getUpperBounds();
- for (Type bound:upperBounds){
- Class<?> boundClass = (Class)bound;
- //如果不写,则默认输出Object,如果写了,则输出对应的
- Log.d(TAG, "upperBound为:" + boundClass.getName());
- }
- }
- }
- }
- }
- }
- }
看到这一大段代码,估计尿血的感觉都出来了。我们对它逐段分析:
首先获取PointWildcardImpl.class所直接继承的接口
- Class<?> clazz = PointWildcardImpl.class;
- Type[] types = clazz.getGenericInterfaces();
- ParameterizedType parameterizedType = (ParameterizedType) type;
- Type[] actualTypes = parameterizedType.getActualTypeArguments();
所以此时的actualTypes也仅有一个元素,它代表的表达式是Comparable<? extends Number>,明显这依然是一个泛型,所以还得继续往下剥
所以继续将其中的actualType进行强转,然后再得到它的填充参数:
- ParameterizedType ComparableType = (ParameterizedType) actualType;
- Type[] compareArgs = ComparableType.getActualTypeArguments();
此时的compareArgs列表中也仅有一个元素,这个元素代表的表达式是:<? extends Number>
这就是一个WildcardType类型了,然后是得到这个WildcardType的上下边界信息了:
完整获取上下边界的代码如下:(后面会分开讲)
- for (Type Arg:compareArgs){
- if(Arg instanceof WildcardType){
- //将得到的对应WildcardType的type强转为WildcardType的变量
- WildcardType wt = (WildcardType) Arg;
- //利用getLowerBounds得到下界,即派生自Super的限定,如果没有派生自super则为null
- Type[] lowerBounds = wt.getLowerBounds();
- for (Type bound:lowerBounds){
- Class<?> boundClass = (Class)bound;
- Log.d(TAG, "lowerBound为:" + boundClass.getName());
- }
- //通过getUpperBounds得到上界,即派生自extends的限定,如果没有,默认是Object
- Type[] upperBounds = wt.getUpperBounds();
- for (Type bound:upperBounds){
- Class<?> boundClass = (Class)bound;
- //如果不写,则默认输出Object,如果写了,则输出对应的类名
- Log.d(TAG, "upperBound为:" + boundClass.getName());
- }
- }
- }
- WildcardType wt = (WildcardType) Arg;
- //利用getLowerBounds得到下界,即派生自Super的限定,如果没有派生自super则为null
- Type[] lowerBounds = wt.getLowerBounds();
- for (Type bound:lowerBounds){
- Class<?> boundClass = (Class)bound;
- Log.d(TAG, "lowerBound为:" + boundClass.getName());
- }
然后再看看如何得到上边界:
- Type[] upperBounds = wt.getUpperBounds();
- for (Type bound:upperBounds){
- Class<?> boundClass = (Class)bound;
- //如果不写,则默认输出Object,如果写了,则输出对应的类名
- Log.d(TAG, "upperBound为:" + boundClass.getName());
- }
结果如下:
好了,到这里,所有有关type的类型就讲完了,但我们上面是逐个分析当前type应该强转为哪种类型的,如果我们稍微疏忽分析错了,或者,我们根本不知道它当前是哪种类型,这要怎么办,我们必须能写出来一个统一的转换函数出来!我们知道type所有的类型总共五种:Class,ParameterizedType,TypeVariable,WildcardType,GenericArrayType;所以我们利用递规的方法来写一个通用类型转换函数出来。
4、Demo:写一个通用类型转换函数
我们这节就要写一个通用的类型转换函数了,1、实现parseClass(Class<?> c)函数
先写一个parseClass的入口函数,用来得到他所直接继承的泛型接口:- private void parseClass(Class<?> c){
- parseTypeParameters(c.getGenericInterfaces());
- }
- private void parseTypeParameters(Type[] types){
- for(Type type:types){
- parseTypeParameter(type);
- }
- }
- private void parseTypeParameter(Type type){
- if(type instanceof Class){
- Class<?> c = (Class<?>) type;
- Log.d(TAG, c.getSimpleName());
- } else if(type instanceof TypeVariable){
- TypeVariable<?> tv = (TypeVariable<?>)type;
- Log.d(TAG, tv.getName());
- parseTypeParameters(tv.getBounds());
- } else if(type instanceof WildcardType){
- WildcardType wt = (WildcardType)type;
- Log.d(TAG, "?");
- parseTypeParameters(wt.getUpperBounds());
- parseTypeParameters(wt.getLowerBounds());
- } else if(type instanceof ParameterizedType){
- ParameterizedType pt = (ParameterizedType)type;
- Type t = pt.getOwnerType();
- if(t != null) {
- parseTypeParameter(t);
- }
- parseTypeParameter(pt.getRawType());
- parseTypeParameters(pt.getActualTypeArguments());
- } else if (type instanceof GenericArrayType){
- GenericArrayType arrayType = (GenericArrayType)type;
- Type t = arrayType.getGenericComponentType();
- parseTypeParameter(t);
- }
- }
2、使用parseClass(Class<?> c)
首先,我们还用上面用PointWildcardImpl类:- public class PointWildcardImpl implements PointSingleInterface<Comparable<? extends Number>> {
- }
- parseClass(PointWildcardImpl.class);
可以看到,打印出了每一个字段的名字。
好了,我们再回过头来看看,parseTypeParameter(Type type)是怎么写的。
3、parseClass(Class<?> c)实现详解
在parseClass(Class<?> c)中,最关键的部分是parseTypeParameter(Type type)函数,所以我们直接对parseTypeParameter(Type type)进行分析。我们知道,type总共有五种类型:Class,ParameterizedType,TypeVariable,WildcardType,GenericArrayType,所以我们在解析type时分别对它的每种类型进行判断,然后分别解析即可:
- if(type instanceof Class){
- Class<?> c = (Class<?>) type;
- Log.d(TAG, c.getSimpleName());
- }
- } else if(type instanceof TypeVariable){
- TypeVariable<?> tv = (TypeVariable<?>)type;
- Log.d(TAG, tv.getName());
- parseTypeParameters(tv.getBounds());
- }
- } else if(type instanceof WildcardType){
- WildcardType wt = (WildcardType)type;
- Log.d(TAG, "?");
- parseTypeParameters(wt.getUpperBounds());
- parseTypeParameters(wt.getLowerBounds());
- }
- } else if(type instanceof ParameterizedType){
- ParameterizedType pt = (ParameterizedType)type;
- parseTypeParameter(pt.getRawType());
- parseTypeParameters(pt.getActualTypeArguments());
- }
- } else if (type instanceof GenericArrayType){
- GenericArrayType arrayType = (GenericArrayType)type;
- Type t = arrayType.getGenericComponentType();
- parseTypeParameter(t);
- }
好了,有关反射中相关泛型的部分就结束了,下面再总结一下,本篇文章中所涉及到的所有函数。
5、本文涉及函数:
- //获取泛型超类的Type
- public Type getGenericSuperclass();
- //获取泛型接口的方法
- public Type[] getGenericInterfaces();
- //获取填充泛型变量的真实参数列表
- Type[] getActualTypeArguments();
- //返回声明此当前泛型表达式的类或接口的Class对象
- Type getRawType();
- //就是得到当前泛型变量的名称;
- String getName();
- //返回表示此类型变量上边界的 Type 对象的数组。如果没有上边界,则默认返回Object;
- Type[] getBounds();
- //当前数组类型所对应的Type
- Type getGenericComponentType();
- //获取通配符的上边界对象列表
- Type[] getUpperBounds();
- //获取通配符的下边界对象列表
- Type[] getLowerBounds();
有关ParameterizedType.getOwnerType()的用法参考 《ParameterizedType.getOwnerType() 函数怎么用?》
如果本文有帮到你,记得加关注哦
本文所涉及源码下载地址:http://download.csdn.net/detail/harvic880925/9306441
请大家尊重原创者版权,转载请标明出处:http://blog.csdn.net/harvic880925/article/details/50085595谢谢