Javaでの反射を学ぶ(一)

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("
------------------------------------------------------------------------");

			/**
			 *     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("
--------------------------------------------------------------------------------");
			/**     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;
	}

}