JAVA反射机制实例

Test1.class

public class Test {
	public void print() {
		try {
			/**
			 * 1.动态加载类的两种方式：
			 */
			//(1)利用反射API，动态检查obj引用的对象类型，创建类
			Object o1=new Test2();
			Class<?> cls=o1.getClass();
			System.out.println("cls:"+cls);
			//(2)利用反射API，检查类名，动态创建类
			String className="test.Test2";
			cls=Class.forName(className);
			System.out.println("cls:"+cls);
			
			/**
			 * 2.动态创建对象(前提：类中必须存在无参构造器)
			 */
			Object obj=cls.newInstance();
			
			/**
			 * 3.动态调用对象的方法
			 */
			//加载对象的方法的四种方式：
			//(1)getDeclaredMethod(方法名,参数类型1,参数类型2...)
			Method method=cls.getDeclaredMethod("test2", int.class);
			System.out.println("method:"+method);
			//(2)getDeclaredMethods(),获取类中所有的方法，与修饰符无关
			Method[] methods=cls.getDeclaredMethods();
			System.out.println("methods:"+methods);
			int index=0;
			for(Method m:methods) {
				System.out.println("method["+(index++)+"]:"+m);
			}
			//(3)getMethod(方法名,参数类型1,参数类型2...)，不常用
			method=cls.getMethod("test2", int.class);
			System.out.println("method:"+method);
			//(4)getMethods()，获取该类和父类中所有的public修饰的方法，不常用
			methods=cls.getMethods();
			System.out.println("methods:"+methods);
			index=0;
			for(Method m:methods) {
				System.out.println("method["+(index++)+"]:"+m);
			}
			//反射API可以打破封装特性（不受访问控制修饰符约束），实现访问不可见的方法和属性 
			//修改方法的访问权限为可访问
			method.setAccessible(true);
			//动态调用方法，准备参数
			method.invoke(obj, 1);
		
			/**
			 * 4.动态访问和修改对象的属性
			 */
			//加载对象的属性的四种方法：
			//(1)getDeclaredField(属性名)，根据属性名获取该类中的属性
			Field field=cls.getDeclaredField("param");
			System.out.println("field:"+field);
			//(2)getDeclaredFields()，获取该类中所有的属性，不受访问控制修饰符限制
			Field[] fields=cls.getDeclaredFields();
			System.out.println("fields:"+fields);
			index=0;
			for(Field f:fields) {
				System.out.println("field["+(index++)+"]:"+f);
			}
			//(3)getField(属性名),根据属性名获取该类及其父类中的某个public修饰的属性
			field=cls.getField("param");
			System.out.println("field:"+field);
			//(4)getFields(),获取该类及其父类中所有public修饰的属性
			fields=cls.getFields();
			System.out.println("fields:"+fields);
			index=0;
			for(Field f:fields) {
				System.out.println("field["+(index++)+"]:"+f);
			}
			//反射API可以打破封装特性（不受访问控制修饰符约束），实现访问不可见的方法和属性 
			//修改属性的访问权限为可访问
			field.setAccessible(true);
			//获取属性值
			Object param=field.get(obj);
			System.out.println("param_1:"+param);
			//修改属性值
			field.set(obj, 3);
			//显示修改后的属性
			System.out.println("param_2:"+field.get(obj));
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Test test=new Test();
		test.print();
	}
}

Test2.class

public class Test2 {
	public int param=1;
	private int param2=2;

	public Test2() {}
	
	private void test2() {}
	
	public static void test2(int num) {
		System.out.println("num:"+num);
	}
	
}