Java反射 测试代码

代码整理自http://dev.csdn.net/article/49/49876.shtm

package reflect;

import java.lang.reflect.*;

public class DumpMethods {
	private double d;
	public static final int i = 37;
	String s = "testing";

	public DumpMethods() {

	}

	protected DumpMethods(int i, double d) {
	}

	public int add(int a, int b) {
		return a + b;
	}

	public static void main(String args[]) {
		try {
			Class c = Class.forName("java.lang.String");

			// 得到指定类java.lang.String拥有的方法，将它们分别列出来。
			Method m[] = c.getDeclaredMethods();
			for (int i = 0; i < m.length; i++) {
				Method mthod = m[i];
				System.out.println(mthod.getName());// 打印方法名
				System.out.println(mthod.getDeclaringClass());// 打印方法名
				// ...得到参数类型
				Class pvec[] = mthod.getParameterTypes();
				for (int j = 0; j < pvec.length; j++)
					System.out.println("param #" + j + " " + pvec[j]);

				// ...得到异常类型
				Class evec[] = mthod.getExceptionTypes();
				for (int j = 0; j < evec.length; j++)
					System.out.println("exc #" + j + " " + evec[j]);

				// ...得到返回类型
				System.out.println("return type = " + mthod.getReturnType());
				System.out.println("-----");

				// ...System.out.println(m[i].toString());//打印方法名
			}

			
			// 获得指定类java.lang.String的构造方法，将它们分别列出来。
			Constructor ctorlist[] = c.getDeclaredConstructors();

			for (int i = 0; i < ctorlist.length; i++) {
				Constructor ct = ctorlist[i];
				System.out.println("name = " + ct.getName());
				System.out.println("decl class = " + ct.getDeclaringClass());
				Class pvec[] = ct.getParameterTypes();
				for (int j = 0; j < pvec.length; j++)
					System.out.println("param #" + j + " " + pvec[j]);
				Class evec[] = ct.getExceptionTypes();
				for (int j = 0; j < evec.length; j++)
					System.out.println("exc #" + j + " " + evec[j]);
				System.out.println("-----");
			}

			
			// 获取当前类中声明的字段（不包括从基类继承来的字段），若替换成c.getFields，则是获得包括从基类继承的所有字段
			Field fieldlist[] = c.getDeclaredFields();
			for (int i = 0; i < fieldlist.length; i++) {
				Field fld = fieldlist[i];
				System.out.println("name = " + fld.getName());
				System.out.println("decl class = " + fld.getDeclaringClass());
				System.out.println("type = " + fld.getType());
				// ...得到修饰符
				int mod = fld.getModifiers();
				System.out.println("modifiers = " + Modifier.toString(mod));
				System.out.println("-----");
			}

			
			// 根据方法的名称来执行方法
			Class partypes[] = new Class[2];
			partypes[0] = Integer.TYPE;
			partypes[1] = Integer.TYPE;
			Method meth = c.getMethod("add", partypes);
			// ...实例化
			DumpMethods methobj = new DumpMethods();
			Object arglist[] = new Object[2];
			arglist[0] = new Integer(37);
			arglist[1] = new Integer(47);
			Object retobj = meth.invoke(methobj, arglist);
			Integer retval = (Integer) retobj;
			// ...这里应当返回add方法的结果
			System.out.println(retval.intValue());

			
			/*
			 * 通过调用构造方法来创建新的对象 根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。
			 * 使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。
			 */
			Constructor ct = c.getConstructor(partypes);
			Object retobj1 = ct.newInstance(arglist);

			
			// 改变字段(域)的值
			Field fld = c.getField("d");
			DumpMethods f2obj = new DumpMethods();
			System.out.println("d = " + f2obj.d);
			// ...改变值 除了setDouble还有其他很多种
			fld.setDouble(f2obj, 12.34);
			System.out.println("d = " + f2obj.d);

			
			// 使用数组,创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋值
			Class cls = Class.forName("java.lang.String");
			Object arr = Array.newInstance(cls, 10);
			Array.set(arr, 5, "this is a test");
			String s = (String) Array.get(arr, 5);
			System.out.println(s);

			
			// 数组的另一个复杂点的例子
			/*
			 * 例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37。
			 * 注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。
			 * 进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。
			 * 注意创建数组时的类型是动态的，在编译时并不知道其类型。
			 */
			int dims[] = new int[] { 5, 10, 15 };
			Object arr1 = Array.newInstance(Integer.TYPE, dims);
			Object arrobj = Array.get(arr1, 3);
			Class cls1 = arrobj.getClass().getComponentType();
			System.out.println(cls1);
			arrobj = Array.get(arrobj, 5);
			Array.setInt(arrobj, 10, 37);
			int arrcast[][][] = (int[][][]) arr;
			System.out.println(arrcast[3][5][10]);
		} catch (Throwable e) {
			System.err.println(e);
		}
	}
}