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、


上一篇:linux下SVN+apache搭建


下一篇:Java反射机制(一):认识Class类