反射之parameterType

ParameterizedType 参数化类型

指的是泛型接口在被继承时泛型的类型；如interface InterfaceSecond extends OriginClassSecond在继承OriginClassSecond接口时未将泛型参数化依旧是T类型，即此时InterfaceSecond的父类型为非参数化类型的OriginClassSecond；而KidClass implements InterfaceFirst<String,Float>在继承时指定了InterfaceSecond的泛型参数为String和Integer，因此此时KidClass的父类型为参数化类型的InterfaceFirst<String,Float>。

• 注：一个子类型的父类型可能是参数化类型，但其超父类型肯定不是参数化类型
  (因为该子类型继承父类型时无法指定其超父类的泛型参数)

方法介绍

• ①getActualTypeArguments()返回参数化类型<T,E<>>中的类型参数数列{T,E<>}

• ②getRawType()参数化类型接口名称

• ③getOwnerType()返回接口所在的外部类，如NestInterface是InterfaceFirst<T, E>的嵌套接口，因此NestInterface.getOwnerType()返回的是InterfaceFirst<T, E>

实例代码

interface God{
}

interface OriginClassFirst<T,E> extends God{
	
}
interface OriginClassSecond<T> extends God{
	
}

interface InterfaceFirst<T, E> extends OriginClassFirst<T,E>{
	interface NestInterface<W>{
		
	}
	
}
interface InterfaceSecond<T> extends OriginClassSecond<T>{
	
}


class FatherClass{
	
}


class KidClass<T> extends FatherClass implements InterfaceFirst<String,Float>,InterfaceSecond<Integer>{
	class NestClass implements NestInterface<Double>{
		
	}
}

public class ParameterizedTypeTest {
	public static <T> void main(String args[]) {
		KidClass<T> kidClass=new KidClass<T>();
		Class<?> c;Class<?> cc;Type[] ts,as;ParameterizedType p;
		//获取对象的类对象
		if((c=kidClass.getClass())!=null) {
			//获取类对象的接口类型对象数列
			if((ts=c.getGenericInterfaces()).length>0) {
				int i=0;
				for (Type t : ts) {
					//打印接口类型名称
					System.out.println(t.getTypeName());
					System.out.println("---------------ts["+i+"]---------------------");
					//只有参数化类型才能执行ParameterizedType的方法
					if(t instanceof ParameterizedType) {			
						p=(ParameterizedType)t;
						//获取泛型参数数列
						as=p.getActualTypeArguments();
						for (Type type : as) {
							System.out.println(type);
						}
						//因为InterfaceFirst和InterfaceSecond无外部接口，因此返回空值
						System.out.println(p.getOwnerType());
						//返回接口名称
						System.out.println(p.getRawType());
						//如果有超父类，验证超父类是否参数化
						if(p.getOwnerType() instanceof ParameterizedType) {
							p=(ParameterizedType)t;
							as=p.getActualTypeArguments();
							for (Type type : as) {
								System.out.println(type);
							}
							System.out.println(p.getOwnerType());
							System.out.println(p.getRawType());
						}
					}else {
						System.out.println(t.toString());
					}
					i++;
				}
			}
		}
		System.out.println("----------------------------------Nested----------------------------------------");
		//获得类对象中的嵌套类对象
		Class<?>[] dcs = c.getDeclaredClasses();
		if(dcs!=null) {
			for(Class dc:dcs) {
				if((ts=dc.getGenericInterfaces()).length>0) {
					int i=0;
					for (Type t : ts) {
						System.out.println(t.getTypeName());
						System.out.println("---------------ts["+i+"]---------------------");
						if(t instanceof ParameterizedType) {			
							p=(ParameterizedType)t;
							System.out.println(p.getRawType());
							System.out.println(p.getOwnerType());
							as=p.getActualTypeArguments();
							for (Type type : as) {
								System.out.println(type);
							}
							//如果有超父类，验证超父类是否参数化
							if(p.getOwnerType() instanceof ParameterizedType) {
								p=(ParameterizedType)t;
								as=p.getActualTypeArguments();
								for (Type type : as) {
									System.out.println(type);
								}
								System.out.println(p.getOwnerType());
								System.out.println(p.getRawType());
							}
						}else {
							System.out.println(t.toString());
						}
						i++;
						System.out.println("---------------------------------------------");
					}
				}
			}
		}
	}
}