java反射技术及代理模式（二）

在例程InvokeTester类的main()方法中，运用反射机制调用一个InvokeTester对象的add()和echo()方法

InvokeTester.java

import java.lang.reflect.Method;

public class InvokeTester
{
    public int add(int param1, int param2)
    {
        return param1 + param2;
    }

    public String echo(String msg)
    {
        return "echo: " + msg;
    }

    public static void main(String[] args) throws Exception
    {
        Class<?> classType = InvokeTester.class;
        Object invokeTester = classType.newInstance();

        // Object invokeTester = classType.getConstructor(new
        // Class[]{}).newInstance(new Object[]{});

        // 调用InvokeTester对象的add()方法
        Method addMethod = classType.getMethod("add", new Class[] { int.class, int.class });
        Object result = addMethod.invoke(invokeTester, new Object[] { new Integer(100), new Integer(200) });
        System.out.println((Integer) result);

        // 调用InvokeTester对象的echo()方法
        Method echoMethod = classType.getMethod("echo", new Class[] { String.class });
        result = echoMethod.invoke(invokeTester, new Object[] { "Hello" });
        System.out.println((String) result);
    }
}

add()方法的两个参数为int 类型，获得表示add()方法的Method对象的代码如下：
Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});
Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回

在本例中，尽管InvokeTester 类的add()方法的两个参数以及返回值都是int类型，调用add Method 对象的invoke()方法时，只能传递Integer 类型的参数，并且invoke()方法的返回类型也是Integer 类型，Integer 类是int 基本类型的包装类：

Object result=addMethod.invoke(invokeTester,
new Object[]{new Integer(100),new Integer(200)});
System.out.println((Integer)result); //result 为Integer类型

*************************************
java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。例程
ArrayTester1 类的main()方法创建了一个长度为10 的字符串数组，接着把索引位置为5 的元素设为“hello”，然后再读取索引位置为5 的元素的值

ArrayTester1.java

import java.lang.reflect.Array;

public class ArrayTester1
{
    public static void main(String args[]) throws Exception
    {
        Class<?> classType = Class.forName("java.lang.String");
        // 创建一个长度为10的字符串数组
        Object array = Array.newInstance(classType, 10);
        // 把索引位置为5的元素设为"hello"
        Array.set(array, 5, "hello");
        // 获得索引位置为5的元素的值
        String s = (String) Array.get(array, 5);
        System.out.println(s);
    }
}

例程ArrayTester2 类的main()方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为[3][5][10] 的元素的值为设37

ArrayTester2.java

import java.lang.reflect.Array;

public class ArrayTester2
{
	public static void main(String args[])
	{
		//定义一个一维数组
		int[] dims = new int[] { 5, 10, 15 };
		//定义一个Array对象，三维数组，
		//Array.newInstance(Integer.TYPE, dims)第二个参数为数组，数组的长度就是维数
		Object array = Array.newInstance(Integer.TYPE, dims);
		//java中多维数组，就是数组的数组，得到一个二维数组
		Object arrayObj = Array.get(array, 3);
		Class<?> cls = arrayObj.getClass().getComponentType();
		System.out.println(cls);
		//得到一个一维数组
		arrayObj = Array.get(arrayObj, 5);
		//给数组的第10个元素设置值
		Array.setInt(arrayObj, 10, 37);

		int arrayCast[][][] = (int[][][]) array;
		System.out.println(arrayCast[3][5][10]);
	}
}

******************************************************

“Class” class

众所周知Java有个Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class object。

Class class十分特殊。它和一般classes一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types
（boolean, byte, char, short, int, long, float, double）以及关键词void。当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class object。如果您想借由“修改Java标准库源码”来观察Class object的实际生成时机（例如在Class的constructor内添加一个println()），不能够！因为Class并没有public constructor

Class是Reflection起源。针对任何您想探勘的class，唯有先为它产生一个Class object，接下来才能经由后者唤起为数十多个的Reflection APIs


“Class” object的取得途径

===========================================================
Class object 诞生管道 = 示例
===========================================================
运用getClass()
注：每个class都有此函数 = String str = "abc";
Class c1 = str.getClass();
===========================================================
运用Class.getSuperclass() = Button b1 = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
===========================================================
运用static method = Class c1 = Class.forName("java.String");
Class.forName()
(最常被使用)
&&&&&&&&&&&&&&&
见上传文件吧，&&&
&&&&&&&&&&&&&&&

运行时生成instances

欲生成对象实体，在Reflection 动态机制中有两种作法，一个针对“无自变量ctor”，一个针对“带参数ctor”。如果欲调用的是“带参数ctor“就比较麻烦些，不再调用Class的newInstance()，而是调用Constructor 的newInstance()。首先准备一个Class[]做为ctor的参数类型（本例指定
为一个double和一个int），然后以此为自变量调用getConstructor()，获得一个专属ctor。接下来再准备一个Object[] 做为ctor实参值（本例指定3.14159和125），调用上述专属ctor的newInstance()。

Class c = Class.forName("DynTest");
Object obj = null;
obj = c.newInstance();//不带自变量
System.out.println(obj);

动态生成“Class object 所对应之class”的对象实体；无自变量。

Class c = Class.forName("DynTest");
Class[] pTypes = new Class[]{double.class,int.class};
Constructor ctor = c.getConstructor(pTypes);
Object obj = null;
Object[] arg = new Object[]{3.124,23};
obj = ctor.newInstance(arg);
System.out.println(obj);

运行时调用methods


这个动作和上述调用“带参数之ctor”相当类似。首先准备一个Class[]做为参数类型（本例指定其中一个是String，另一个是Hashtable），然后以此为自变量调用getMethod()，获得特定的Method object。接下来准备一个Object[]放置自变量，然后调用上述所得之特定Method object的invoke()。
为什么获得Method object时不需指定回返类型？

因为method overloading机制要求signature必须唯一，而回返类型并非signature的一个成份。换句话说，只要指定了method名称和参数列，就一定指出了一个独一无二的method。

Class c = Class.forName("java.lang.String");
Method method = c.getMethod("method name",方法参数类型);


**************************
与先前两个动作相比，“变更field内容”轻松多了，因为它不需要参数和自变量。首先调用Class的getField()并指定field名称。获得特定的Field object之后便可直接调用Field的get()和set()，

import java.lang.reflect.Field;

public class Test {
	public double d;
	public static void main(String[] args) throws Exception {
		Class<?> c = Class.forName("Test");
		//利用字段名得到一个Field对象
		Field f = c.getField("d");
		Test obj = new Test();
		//利用Field类的get方法得到某个对象的此字段
		System.out.println("d= "+(Double)f.get(obj));
		f.set(obj, 12.36);
		System.out.println("d= "+obj.d);
	}
}