欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

学习java中的反射(一)

程序员文章站 2024-01-20 11:56:52
...

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

   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;
	}

}