Java反射机制（三）：调用对象的私有属性和方法

一、 通过反射调用类中的方法

在正常情况下，得到类的对象后，我们就可以直接调用类中的方法了，如果要想调用的话，则肯定必须清楚地知道要调用的方法是什么，之后通过Class类中的getMethod方法，可得到Method对象。

public Method getMethod(String name,
                        Class<?>... parameterTypes)
                 throws NoSuchMethodException,
                        SecurityException

当获取到Method对象后，可以通过该对象来执行方法，但是在方法调用的时候，因为会牵扯到方法中参数的问题，所以通过getMethod（）取得的时候，必须设置好参数类型。

package org.chen.yuan.reflect;
interface China{	// 定义China接口
	public static final String NATIONAL = "China" ;	// 定义全局常量
	public static final String AUTHOR = "李兴华" ;	// 定义全局常量
	public void sayChina() ;		// 无参的，没有返回值的方法
	public String sayHello(String name,int age) ;	// 定义有两个参数的方法，并返回内容
}
public class Person implements China{
	private String name ;
	private int age ;
	public Person(){	// 无参构造
	}
	public Person(String name){
		this.name = name ;	// 设置name属性
	}
	public Person(String name,int age){
		this(name) ;
		this.age = age ;
	}
	public void sayChina(){	// 覆写方法
		System.out.println("作者：" + AUTHOR + "，国籍：" + NATIONAL) ;
	}
	public String sayHello(String name,int age){
		return name + "，你好！我今年：" + age + "岁了！" ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
};

我们调用sayChina（）方法，此方法中没有任何参数。

执行调用的方法，需通过Method的invoke方法来实现：

public Object invoke(Object obj,
                     Object... args)
              throws IllegalAccessException,
                     IllegalArgumentException,
                     InvocationTargetException

示例1：（调用无参的方法）

package org.chen.yuan.reflect;
interface China{	// 定义China接口
	public static final String NATIONAL = "China" ;	// 定义全局常量
	public static final String AUTHOR = "沉缘" ;	// 定义全局常量
	public void sayChina() ;		// 无参的，没有返回值的方法
	public String sayHello(String name,int age) ;	// 定义有两个参数的方法，并返回内容
}
public class Person implements China{
	private String name ;
	private int age ;
	public Person(){	// 无参构造
	}
	public Person(String name){
		this.name = name ;	// 设置name属性
	}
	public Person(String name,int age){
		this(name) ;
		this.age = age ;
	}
	public void sayChina(){	// 覆写方法
		System.out.println("作者：" + AUTHOR + "，国籍：" + NATIONAL) ;
	}
	public String sayHello(String name,int age){
		return name + "，你好！我今年：" + age + "岁了！" ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
};

我们在Person.java 类中定义了一个无参方法sayChina和一个有参数的方法sayHello，接下来，我们调用无参数的方法：

package org.chen.yuan.reflect;

import java.lang.reflect.Method;

public class InvokeSyaChinaDemo
{
    public static void main(String[] args)
    {
        Class<?> c1 = null;
        try
        {
            c1 = Class.forName("org.chen.yuan.reflect.Person");
            Method met = c1.getMethod("sayChina");
            met.invoke(c1.newInstance());
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

输出： 作者：沉缘，国籍：China

可以看出，通过上述反射的方式，我们能够顺利的调用Person类中的方法。 那思考下，如果我们要调用含有参数的方法sayHello，该如何做呢？

可以想象，如果方法里存在了参数，则必须设置参数的类型及内容。

public class InvokeSayHelloDemo
{

    public static void main(String[] args) throws Exception
    {
        Class<?> c1 = null;
        c1 = Class.forName("org.chen.yuan.reflect.Person");
        Method met = c1.getMethod("sayHello", String.class, int.class);
        String result = (String) met.invoke(c1.newInstance(), "沉缘", 25);
        System.out.println(result);
    }

}

输出： 沉缘，你好！我今年：25岁了！

二、 通过反射调用类中的setter及getter方法

setter和getter方法是访问类属性的标准方法，如果一个类中的属性被封装，则必须通过setter及getter方法设设置和取得，实际上此方法的操作之所以要这样规定，主要是由于反射机制可以给予支持。

通过反射可以调用setter及getter方法。

package org.chen.yuan.reflect;

import java.lang.reflect.Method;

public class InvokeSetGetDemo
{

    public static void main(String[] args) throws Exception
    {
        Class<?> c1 = null;
        Object obj = null;

        c1 = Class.forName("org.chen.yuan.reflect.Person");
        obj = c1.newInstance();

        setter(obj, "name", "沉缘", String.class);
        getter(obj, "name");

        setter(obj, "age", 25, int.class);
        getter(obj, "age");
    }

    /**
     * @param obj 要操作的对象
     * @param att 要操作的属性
     * @param value 要设置的属性数据
     * @param type 要设置的属性的类型
     */
    public static void setter(Object obj, String att, Object value, Class<?> type)
    {
        try
        {
            Method met = obj.getClass().getMethod("set" + initStr(att), type);
            met.invoke(obj, value);

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * @param obj 要操作的对象
     * @param att 要操作的属性
     */
    public static void getter(Object obj, String att) throws Exception
    {
        Method met = obj.getClass().getMethod("get" + initStr(att));
        System.out.println(met.invoke(obj));
    }

    /**
     * 将单词首字母大写
     *
     * @param old
     * @return
     */
    public static String initStr(String old)
    {
        String newStr = old.substring(0, 1).toUpperCase() + old.substring(1);
        return newStr;
    }
}

三、 通过反射调用属性

如果假设要操作一个类中的属性，则也可以通过Field完成，而不必麻烦的通过setter和getter。Class类中，获取类中Field的方法：

1） 得到类中公共属性

public Field getField(String name)
               throws NoSuchFieldException,
                      SecurityException

2）得到本类属性

public Field getDeclaredField(String name)
                       throws NoSuchFieldException,
                              SecurityException

而在Field类中，提供了获取属性内容及设置属性内容的方法：

1） 获取属性内容

public Object get(Object obj)
           throws IllegalArgumentException,
                  IllegalAccessException

2） 设置属性内容

public void set(Object obj,
                Object value)
         throws IllegalArgumentException,
                IllegalAccessException

还有一点需要注意，访问类中的私有属性时，必须要让该属性对外可见：

public void setAccessible(boolean flag)
                   throws SecurityException

该方法继承自Field的父类：

java.lang.reflect

Class AccessibleObject

只要把该方法的参数内容设置为true即可。

public class InvokeFieldDemo
{
    public static void main(String args[]) throws Exception
    {
        Class<?> c1 = null;
        Object obj = null;
        c1 = Class.forName("org.chen.yuan.reflect.Person"); // 实例化Class对象
        obj = c1.newInstance();
        Field nameField = null;
        Field ageField = null;
        nameField = c1.getDeclaredField("name"); // 取得name属性
        ageField = c1.getDeclaredField("age"); // 取得name属性
        nameField.setAccessible(true); // 此属性对外部可见
        ageField.setAccessible(true); // 此属性对外部可见
        nameField.set(obj, "沉缘"); // 设置name属性内容
        ageField.set(obj, 25); // 设置age属性内容
        System.out.println("姓名：" + nameField.get(obj));
        System.out.println("年龄：" + ageField.get(obj));
    }
};

输出：

姓名：沉缘

年龄：25

可见，操作属性，未必需要setter和getter方法的支持，但是，为了保证程序的安全性，最好还是通过setter和getter方法对属性进行操作。

四、 通过反射操作数组

反射机制不光能用在类中，也可以应用在任意的引用数据类型上，当然，这就包含了数组，数组使用Array类完成。

Class类中存在以下一个方法：

public Class<?> getComponentType()

Array类中得到数组指定下标的内容：

public static Object get(Object array,
                         int index)
                  throws IllegalArgumentException,
                         ArrayIndexOutOfBoundsException

Array类中修改内容：

public static void set(Object array,
                       int index,
                       Object value)
                throws IllegalArgumentException,
                       ArrayIndexOutOfBoundsException

Array类中开辟新的数组：

public static Object newInstance(Class<?> componentType,
                                 int... dimensions)
                          throws IllegalArgumentException,
                                 NegativeArraySizeException

取得数组信息并修改内容：

package org.chen.yuan.reflect;
import java.lang.reflect.Array ;
public class ClassArrayDemo{
	public static void main(String args[]) throws Exception{
		int temp[] = {1,2,3} ;// 声明一整型数组
		Class<?> c = temp.getClass().getComponentType() ;	// 取得数组的Class对象
		System.out.println("类型：" + c.getName()) ;	// 取得数组类型名称
		System.out.println("长度：" + Array.getLength(temp)) ;
		System.out.println("第一个内容：" + Array.get(temp,0)) ;
		Array.set(temp,0,6) ;
		System.out.println("第一个内容：" + Array.get(temp,0)) ;
	}
};

输出：

类型：int

长度：3

第一个内容：1

第一个内容：6

数组修改的过程，实际上就是创建一个新的数组的过程，所以要把旧的数组内容拷贝到新的数组中去。

package org.chen.yuan.reflect;

import java.lang.reflect.Array;

public class ChangeArrayDemo
{
    public static void main(String args[]) throws Exception
    {
        int temp[] = {1, 2, 3};// 声明一整型数组
        int newTemp[] = (int[]) arrayInc(temp, 5); // 重新开辟空间5
        print(newTemp);
        System.out.println("\n-------------------------");
        String t[] = {"chenyuan", "wuqing", "lengxue"};
        String nt[] = (String[]) arrayInc(t, 8);
        print(nt);
    }

    public static Object arrayInc(Object obj, int len)
    {
        Class<?> c = obj.getClass();
        Class<?> arr = c.getComponentType(); // 得到数组的
        Object newO = Array.newInstance(arr, len); // 开辟新的大小
        int co = Array.getLength(obj);
        System.arraycopy(obj, 0, newO, 0, co); // 拷贝内容
        return newO;
    }

    public static void print(Object obj)
    { // 数组输出
        Class<?> c = obj.getClass();
        if (!c.isArray())
        { // 判断是否是数组
            return;
        }
        Class<?> arr = c.getComponentType();
        System.out.println(arr.getName() + "数组的长度是：" + Array.getLength(obj)); // 输出数组信息
        for (int i = 0; i < Array.getLength(obj); i++)
        {
            System.out.print(Array.get(obj, i) + "、"); // 通过Array输出
        }
    }
};

输出：

nt数组的长度是：5

1、2、3、0、0、

-------------------------

java.lang.String数组的长度是：8

chenyuan、wuqing、lengxue、null、null、null、null、null、