java反射实例——java.lang.reflect

    本文主要解释一下几个问题

1、如何根据对象获得类的所有方法和属性

2、如何根据类名获得类的方法和属性

3、如何选择被反射类的构造函数 并 调用该函数获得实例

4、如何批量执行无参函数

5、如何调用指定名字的方法

6、如何调用有参的函数

7、如何反射调用类的私有方法

————————————————————————————————————

package com.hhf.reflect;

/**
 * 等待被反射的类
 * 用于解释如何通过反射获得类的方法与属性 
 * 如何选择被反射类的构造函数
 * 如何批量执行类的函数
 * @author HHF
 * 2014年4月17日
 */

public class DataFunc {
  private int data1;
  private int data2;
  private int result;

  public DataFunc() {
    data1=0;
    data2=0;
    result=0;
  }
  public DataFunc(int x,int y){
    data1=x;
    data2=y;
   
  }

  public int add(){
    result=data1+data2+1;
    return result;
  }
  
  public int substract(){
    result=data1-data2;
    return result;
  }

  public int multiply(){
    result=data1*data2;
    return result;
  }
  
  public int divide(){
	  result=data1/data2;
	  return result;
	  
  }
  

}

 

package com.hhf.reflect;

/**
 * 等待被反射的类
 * 主要为了解释一个有参的方法如何反射调用
 * @author HHF
 * 2014年4月17日 
 */
public class DataFunc2 {
	@SuppressWarnings("unused")
	private int data1;
	@SuppressWarnings("unused")
	private int data2;
	private int result;

	public DataFunc2() {
		data1 = 0;
		data2 = 0;
		result = 0;
	}

	public DataFunc2(int x, int y) {
		data1 = x;
		data2 = y;

	}

	public int add2(int a, int b, int c) {
		result = a + b + c;
		return result;
	}
}

 

package com.hhf.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Refect {

	// JAVA反射机制是在	运行状态	中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
	// Java反射机制主要提供了以下功能：
	// 在运行时判断任意一个对象所属的类；
	// 在运行时构造任意一个类的对象；
	// 在运行时判断任意一个类所具有的成员变量和方法；
	// 在运行时调用任意一个对象的方法；生成动态代理。

	// 使用反射机制的步骤：
	// 导入java.lang.relfect 包
	// 遵循三个步骤
	// 第一步是获得你想操作的类的 java.lang.Class 对象
	// 第二步是调用诸如 getDeclaredMethods 的方法
	// 第三步使用 反射API 来操作这些信息
	public static void main(String [] args){
		Refect refect = new Refect();
		System.out.println("-----------------------通过对象获得方法和属性------------------------");
		refect.reflectInstance();
		System.out.println("-----------------------通过类名获得方法与参数----------------------------");
		refect.reflectClass();
		System.out.println("-----------------------批量执行方法------------------------------");
		refect.RunMethod();
		System.out.println("-----------------------调用指定无参方法----------------------------");
		refect.RunSepcMethod();
		System.out.println("-----------------------调用有参数方法------------------------------");
		refect.RunParmMethod();
	}
	/**
	 * 通过对象获得类的	方法和属性
	 */
	public void reflectInstance() {
		try {			
			DataFunc a = new DataFunc();
			Class cla = Class.forName(a.getClass().getName());// 根据类的全路径进行类加载，返回该类的Class对象
			Method[] method = cla.getDeclaredMethods();// 利用得到的Class对象的自审，返回方法对象集合
			System.out.println("********该类的所有方法********");
			for (Method me : method) {// 遍历该类方法的集合
				System.out.println(me.toString());// 打印方法信息
			}
			System.out.println("********该类的所有属性********");
			Field[] field = cla.getDeclaredFields();// 利用得到的Class对象的自审，返回属性对象集合
			for (Field me : field) { // 遍历该类属性的集合
				System.out.println(me.toString());// 打印属性信息
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 通过类的完整路径获得类的	方法和属性
	 */
	public void reflectClass() {

		try {			
			Class cla = Class.forName("com.hhf.reflect.DataFunc");// 根据类的全路径进行类加载，返回该类的Class对象
			Method[] method = cla.getDeclaredMethods();// 利用得到的Class对象的自审，返回方法对象集合
			System.out.println("********该类的所有方法********");
			for (Method me : method) {// 遍历该类方法的集合
				System.out.println(me.toString());// 打印方法信息
			}
			System.out.println("********该类的所有属性********");
			Field[] field = cla.getDeclaredFields();// 利用得到的Class对象的自审，返回属性对象集合
			for (Field me : field) { // 遍历该类属性的集合
				System.out.println(me.toString());// 打印属性信息
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 指定构造函数
	 * 可以另外的通过构造函数给函数属性传递参数 并调用方法
	 */
	public void RunMethod() {
		try {
			// 获得指定字符串类对象
			Class cla = Class.forName("com.hhf.reflect.DataFunc");
			// 设置Class对象数组，用于指定构造方法类型
			Class[] cl = new Class[] { int.class, int.class };
			// 获得Constructor构造器对象。并指定构造方法类型
			Constructor con = cla.getConstructor(cl);
			// 给传入参数赋初值
			Object[] x = { new Integer(33), new Integer(67) };
			// 得到实例
			Object obj = con.newInstance(x);

			Method[] method = cla.getDeclaredMethods();// 利用得到的Class对象的自审，返回方法对象集合
			//批量调用方法（无参数的方法）
			for (Method me : method) {// 遍历该类方法的集合
				System.out.print("调用方法："+me.toString());// 打印方法信息
				String str = me.invoke(obj).toString();
				System.out.println("\t该方法执行结果"+str);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 指定方法名的调用方法
	 */
	public void RunSepcMethod() {
		try {
			// 获得指定字符串类对象
			Class cla = Class.forName("com.hhf.reflect.DataFunc");
			// 设置Class对象数组，用于指定构造方法类型
			Class[] cl = new Class[] { int.class, int.class };
			// 获得Constructor构造器对象。并指定构造方法类型
			Constructor con = cla.getConstructor(cl);
			// 给传入参数赋初值
			Object[] x = { new Integer(33), new Integer(67) };
			// 得到实例
			Object obj = con.newInstance(x);
			
			Method specMethod = cla.getMethod("add");
			String str = specMethod.invoke(obj).toString();
			System.out.println("调用方法"+specMethod.getName()+"的结果\t"+str);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 调用有参数的方法
	 */
	public void RunParmMethod() {
		try {
			// 获得指定字符串类对象
			Class cla = Class.forName("com.hhf.reflect.DataFunc2");
			// 设置Class对象数组，用于指定构造方法类型
			Class[] cl = new Class[] { int.class, int.class };
			// 获得Constructor构造器对象。并指定构造方法类型
			Constructor con = cla.getConstructor(cl);
			// 给传入参数赋初值
			Object[] x = { new Integer(33), new Integer(67) };
			// 得到实例
			Object obj = con.newInstance(x);	

//			Method specMethod1 = cla.getMethod("a", int.class, int.class);
			Class[] c2 = new Class[] { int.class, int.class, int.class};
			Method parmMethod = cla.getMethod("add2", c2);
			// 给传入参数赋初值
			Object[] x2 = { new Integer(3), new Integer(6), new Integer(1)};
			// 得到实例
			String str = parmMethod.invoke(obj, x2).toString();
			System.out.println("调用方法"+parmMethod.getName()+"的结果\t"+str);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

 

//等待被反射的类 其中只有一个私有方法
public class PrivateMethod {
	//私有方法
	private int add(int a, int b){		
		return a +b+1 ;
	}
}

 

//反射调用私有方法
//获取目标类的class对象
Class<PrivateMethod> class1 = PrivateMethod.class;
//获取目标类的实例
Object instance = class1.newInstance();		
//getDeclaredMethod（）  可获取 公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Method method = class1.getDeclaredMethod("add", new Class[]{int.class,int.class});		
//值为true时 反射的对象在使用时 应让一切已有的访问权限取消
method.setAccessible(true);	
Object result = method.invoke(instance, new Object[]{1,2});