java基础增强之反射

反射

反射机制主要应用于框架（Spring，SpringMvc，Struts…），反射主要也就是去研究class对象。

通过反射查看类的信息
每个类被加载后，系统都会为该类生成一个对应的class对象，通过这个class对象即可访问到JVM中的类。
获得class对象：

• 使用class的forName(“类的全路径”);
• 调用某个对象的getClass();
• 调用某个类的class属性

		Class c1=Class.forName("cn.ly.people");
		
		Class c2=people.class;
		
		people p=new people();
		Class c3=p.getClass();

通过反射生成对象

创建一个people类

package cn.ly;
class people {	
		public String name;
		public  int age;
		public void show() {
			System.out.println("hello");			
		}	
}

		//得到people的class对象
		Class c1=Class.forName("cn.ly.people");
		//通过class对象创建实例	
		people p=(people) c1.newInstance();
		//调用方法
		p.show();

用指定的构造器创建函数

package cn.ly;
class people {	
		public String name;
		public  int age;
		public void show() {
			System.out.println("hello"+name);			
		}
		public people() {
			
		}
		public people(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}	
}

		Class c1=Class.forName("cn.ly.people");
		//通过class对象来得到构造函数
		Constructor cs=c1.getConstructor(String.class,int.class);
		people p=(people) cs.newInstance("小明",21);
		p.show();		

使用反射调用方法

		//通过反射创建实例
		Class c1=Class.forName("cn.ly.people");
		//得到构造函数
		Constructor cs=c1.getConstructor(String.class,int.class);
		people p=(people) cs.newInstance("小明",21);
		//使用反射来调用无参数的show方法
		Method me=c1.getMethod("show", null);
		//invoke的第一个参数表示对象实例
		//第二个参数是个可变参数，表示你给方法传递的值
		me.invoke(p,null );

		Class c1=Class.forName("cn.ly.people");
		//得到构造函数
		Constructor cs=c1.getConstructor(String.class,int.class);
		people p=(people) cs.newInstance("小明",21);
		//使用反射来调用有参数的show方法
		Method me=c1.getMethod("show", String.class);
		//invoke的第一个参数表示对象实例
		//第二个参数是个可变参数，表示你给方法传递的值
		me.invoke(p, "小红");

类的外部访问私有方法

		Class c1=Class.forName("cn.ly.people");
		//得到构造函数
		Constructor cs=c1.getConstructor(String.class,int.class);
		people p=(people) cs.newInstance("小明",21);
		//使用反射来调用show方法（两个参数）
        Method me=c1.getDeclaredMethod("show", String.class ,int.class);
        me.setAccessible(true);//暴力访问
        me.invoke(p, "张三",21);
	}

使用反射访问属性值
访问属性name的值

	//得到class对象，创建实例
		Class c1=Class.forName("cn.ly.people");
		people p=(people) c1.newInstance();
		//获取对象的属性name
		Field f=c1.getField("name");
		//得到具体的值
		String name=(String) f.get(p);
		System.out.println(name);

已知一个文件，利用反射机制访问并调用函数

classPath=cn.ly.cat
method=show
parameter=name
parameterType1=java.lang.String
parameterVal1=hello,world
parameterType2=java.lang.Integer
parameterVal2=100

	   Properties p=new Properties();
		FileInputStream f= new FileInputStream("classinfo.properties");
		p.load(f);
		//读取文件内容
		String classpath=p.getProperty("classPath");
		String method=p.getProperty("method");
		String parameter=p.getProperty("parameter");
		String parameterType1=p.getProperty("parameterType1");
		String parameterVal1=p.getProperty("parameterVal1");
		String parameterType2=p.getProperty("parameterType2");
		String parameterVal2=p.getProperty("parameterVal2");
		//获得cat的class对象
		Class c1 =Class.forName("cn.ly.cat");
		//创建一个cat实例
		Object o=c1.newInstance();
		//获得方法
		Method m=c1.getMethod(method,Class.forName(parameterType1),Class.forName(parameterType2) );
		
		Class c2=Class.forName(parameterType1);
		Constructor co1 =c2.getConstructor(parameterVal1.getClass());
		Class c3=Class.forName(parameterType2);
		Constructor co2 =c3.getConstructor(parameterVal2.getClass());
		m.invoke(o,co1.newInstance(parameterVal1),co2.newInstance(parameterVal2));

package cn.ly;

public class cat {

	private String name;
	public void show(String name,Integer num) {
		System.out.println(name+num);
	}
}