学习java中的反射（一）

   说明：一下代码是参考网上一份代码，结合自己的分析进行学习的。这篇文章的内容后续会进行相应的修改

   package com.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;

/**

 */
interface GenericInterface {
};

class GenericSuperClass {
};

interface IClassTestA<A, B> extends GenericInterface {
	String printA(A a);
}

interface IClassTestB<A, B> extends GenericInterface {
	String printB(B b);
}

interface IClassTestC extends GenericInterface {
	String printC();
}

class ClassTestC<A, B> extends GenericSuperClass implements IClassTestA<A, B> {
	@Override
	public String printA(A a) {
		System.out.println("this is A:" + a);
		return null;
	}
}

public class ClassTest<A, B> extends ClassTestC<A, B> implements
		IClassTestB<A, B>, IClassTestC {
	private A a;
	private B b;
	private String c;

	private ClassTest() {

	}

	public ClassTest(A a, B b) {
		this.a = a;
		this.b = b;
		System.out.println("constructor :" + a.toString() + b.toString());
	}

	@Override
	public String printB(B b) {
		System.out.println("this is B:" + b);
		return null;
	}

	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		try {
			Class<ClassTest> classTest = ClassTest.class;
			/** 类所实现的接口 */
			Class[] intf = classTest.getInterfaces();
			System.out.print("类实现的接口：");
			for (Class c : intf) {
				System.out.print(c.toString() + "  ");
			}
			System.out
					.println("\n------------------------------------------------------------------------");

			/**
			 * 取得接口Type[] getGenericInterfaces public Type[]
			 * getGenericInterfaces()返回表示某些接口的 Type，这些接口由此对象所表示的类或接口直接实现。
			 * 如果超接口是参数化类型，则为它返回的 Type
			 * 对象必须准确反映源代码中所使用的实际类型参数。如果以前未曾创建表示每个超接口的参数化类型
			 * ，则创建这个类型。有关参数化类型创建过程的语义，请参阅 ParameterizedType 声明。
			 * 
			 * 如果此对象表示一个类，则返回一个包含这样一些对象的数组，这些对象表示该类实现的所有接口。
			 * 数组中接口对象顺序与此对象所表示的类的声明的 implements 子句中接口名顺序一致。对于数组类，接口 Cloneable 和
			 * Serializable 以该顺序返回。
			 * 
			 * 如果此对象表示一个接口，则该数组包含表示该接口直接扩展的所有接口的对象。数组中接口对象顺序与此对象所表示的接口的声明的
			 * extends 子句中接口名顺序一致。
			 * 
			 * 如果此对象表示一个不实现任何接口的类或接口，则此方法返回一个长度为 0 的数组。
			 * 
			 * 如果此对象表示一个基本类型或 void，则此方法返回一个长度为 0 的数组。
			 * 
			 * 
			 * 返回： 此类所实现的接口的一个数组
			 */
			Type[] types = classTest.getGenericInterfaces();

			System.out.print("Type[] getGenericInterfaces：");
			// IClassTestC不属于以下四种子类
			for (Type type : types) {
				// ParameterizedType 表示参数化类型也就是泛型 ，如 Collection<String>。
				if (type instanceof ParameterizedType) {
					System.out.print("  ParameterizedType：" + type.toString());
					// ParameterizedType:complex.java.lang.IClassTestB<A, B>

					// 取该type的实际类型 Type[] (泛型的实际类型)
					Type[] ts = ((ParameterizedType) type)
							.getActualTypeArguments();
					System.out.print("  ts的长度是：" + ts.length);
					for (Type t : ts) {
						if (t instanceof ParameterizedType) {
							// 循环了--------------------
							System.out.print("ParameterizedType:"
									+ t.toString() + " ");
						}
						// GenericArrayType 表示一种数组类型，其组件类型为参数化类型或类型变量
						if (t instanceof GenericArrayType) {
							System.out
									.print("GenericArrayType:" + t.toString());
						}
						/**
						 * TypeVariable 是各种类型变量的公共高级接口。
						 * 类型变量在反射方法首次需要时创建（在此包中指定）。 如果类型变量 t 由类型（即类、接口或注释类型）T
						 * 引用， 而且 T 由 T 的第 n 个封闭类声明（请参见 JLS 8.1.2） ，那么创建 t
						 * 需要解析（请参见 JVMS 5）T 的第 i 个封闭类，其中 i = 0 到 n（包含）。
						 * 创建某个类型变量决不能导致创建其边界。重复创建类型变量没有效果。
						 * 可以在运行时将多个对象实例化，以表示一个给定的类型变量。
						 * 尽管类型变量仅创建一次，这并不意味着任何缓存实例的要求都表示类型变量。
						 * 不过，表示类型变量的所有实例彼此必须相等 (equal())。
						 * 因此，使用类型变量的用户决不能依靠实现此接口的类实例的身份。
						 */
						// A,B就属于此类型
						if (t instanceof TypeVariable) {
							System.out.print("   TypeVariable:" + t.toString());
						}
					}
				}

				// ####################################
				if (type instanceof GenericArrayType) {
					System.out.print("属于GenericArrayType类型:" + type.toString());
				}
				if (type instanceof TypeVariable) {
					System.out.print("属于TypeVariable类型:" + type.toString());
				}
				if (type instanceof WildcardType) {
					System.out.print("属于WildcardType类型:" + type.toString());
				}
			}

			System.out
					.println("\n--------------------------------------------------------------------------------");
			/** 取得父类Type */
			Type type = classTest.getGenericSuperclass();
			System.out.println("父类的type：" + type.toString());
			System.out
					.println("---------------------------------------------------------------------------------");

			/** ############################################# */
			/** 取得属性 */
			ClassTest ct = new ClassTest();
			// public属性
			Field[] fields = classTest.getFields();
			// 所有声明的属性
			fields = classTest.getDeclaredFields();
			for (Field field : fields) {
				// field.get(ct)为ct对象的各field值
				System.out.println("ct's  " + field.toGenericString() + ":"
						+ field.get(ct));
			}
			System.out
					.println("-----------------------------------------------------------------");
			/** 取得构造方法 */
			// 取得public的构造方法
			Constructor[] constructors = classTest.getConstructors();
			// 取得所有声明的构造方法
			constructors = classTest.getDeclaredConstructors();
			for (Constructor constructor : constructors) {
				// 构造方法的名称
				System.out.println(constructor.getName());
				// 构造方法的 Java 语言修饰符
				System.out.println(constructor.getModifiers());
				Class<?>[] cs = constructor.getParameterTypes();
				for (Class c : cs) {
					System.out.println("constructor.getParameterTypes"
							+ c.toString());
				}
				System.out.println(constructor.toGenericString());
			}

			/** 取得方法 */
			// public方法
			Method[] methods = classTest.getMethods();
			// 所有声明的方法
			methods = classTest.getDeclaredMethods();
			for (Method method : methods) {
				System.out.println(method.toGenericString());
			}
			// 取得某个具体方法
			Method method = classTest.getMethod("getTest", String.class);
			// 调用ct对象的该方法
			method.invoke(ct, "++++++++++++++this getTest");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public String printC() {
		// TODO Auto-generated method stub
		return "classTest printC()";
	}

	public String getTest(String a) {
		System.out.println(a);
		return "来自classTest getTest(String a)";
	}

	public A getA() {
		return a;
	}

	public void setA(A a) {
		this.a = a;
	}

	public B getB() {
		return b;
	}

	public void setB(B b) {
		this.b = b;
	}

}