Java的反射技术

java的反射可以绕过访问权限，访问到类的非公有方法和成员，利用反射还可以访问内部类、匿名内部类的私有属性。可能这点会引起安全性的讨论。反射的使用帮助解决很多复杂的问题，其运行时的类型检查，动态调用，代理的实现等，反射为我们写程序带来了很大的灵活性，很多功能都是基于反射。

一、实体类

package cn.moving.reflect;

import java.io.InputStream;
import java.util.List;

public class Person {
	private String name = "maomao";
	private int password;
	private static int age = 23;
	private static final Person instance = new Person();

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getPassword() {
		return password;
	}

	public void setPassword(int password) {
		this.password = password;
	}

	public static int getAge() {
		return age;
	}

	public static void setAge(int age) {
		Person.age = age;
	}

	private Person() {
		System.out.println("person");
	}

	public static Person getInstance() {
		return Person.instance;
	}

	public Person(String name) {
		this.name = name;
		System.out.println("person name");
	}

	public Person(String name, int age) {
		System.out.println("姓名：" + name + "年龄：" + age);
	}

	public Person(int age) {
		System.out.println("age");
	}

	public Person(List list) {
		System.out.println("list");
	}

	public void play(String name, int age) {
		System.out.println("姓名：" + name + "年龄：" + age + "正在玩");
	}

	public Class[] aa(String name, int[] password) {
		return new Class[] { String.class };
	}

	private void bb(InputStream is) {
		System.out.println(is);
	}

	public static void cc(int num) {
		System.out.println(num);
	}

	public static void main(String args[]) {
		for (String s : args) {
			System.out.println(s);

		}
	}

}

二、反射字段

package cn.moving.reflect;

import java.lang.reflect.Field;

import org.junit.Test;

public class ReflectField {

	/**
	 * 反射类的字段
	 * @throws Exception
	 * @throws SecurityException
	 */
	// 解剖（=反射）private String name = "maomao";
	// 私有字段
	@Test
	public void reflectName() throws SecurityException, Exception {
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Field f = clazz.getDeclaredField("name");
		f.setAccessible(true);
		Person p = new Person("haha");
		Object value = f.get(p);
		Class type = f.getType();
		System.out.println(type);
		if (type.equals(String.class)) {
			String name_value = (String) value;
			System.out.println(name_value);
		}
		f.set(p, "LanWenTao");
		System.out.println(f.get(p));
	}
	@Test
	// private static int age = 23;静态私有的属性
	public void reflectAge() throws Exception {
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Field f = clazz.getDeclaredField("age");
		f.setAccessible(true);
		System.out.println(f.get(null));;
	}

}

三、反射构造方法

package cn.moving.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;

public class ReflectConstructor {

	/**
	 * 反射构造方法
	 * 
	 * @throws ClassNotFoundException
	 * @throws InvocationTargetException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 * @throws IllegalArgumentException
	 */

	@Test
	public void reflectNoArgumentConstrustor() throws Exception {
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Constructor[] cons = clazz.getDeclaredConstructors();
		Constructor c = null;
		for (Constructor con : cons) {
			con.setAccessible(true);
			c = con;
		}
		Person p = (Person) c.newInstance(null);
		System.out.println(p.getName());
	}

	@Test
	public void reflectConstructor() throws Exception {
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Constructor c = clazz.getConstructor(String.class, int.class);
		Person p = (Person) c.newInstance("XiaoMing", 22);
		System.out.println(p.getName());// ???????????
	}
}

四、反射普通方法

package cn.moving.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

import org.junit.Test;

public class reflectMethod {

	/**
	 * 反射普通方法
	 */
	// public void play(String name, int age)
	@Test
	public void reflectPlay() throws Exception {
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Method method = clazz.getMethod("play", String.class, int.class);
		Person p = new Person("ZhangSan",22);
		method.invoke(p, "sdfdsf",44);
	}
	//public Class[] aa(String name, int[] password)
	@Test
	public void reflectClass() throws Exception{
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Method method = clazz.getMethod("aa", String.class,int[].class);
		Person p = Person.getInstance();
		Class[] cs =(Class[]) method.invoke(p, "ZhangSan",new int[]{12,332,4,23,4});
		System.out.println(cs[0]);
		System.out.println(p.getName());
	} 
	
	@Test
	//private void bb(InputStream is)
	public void reflectbb() throws Exception{
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Method method  = clazz.getDeclaredMethod("bb", InputStream.class);
		method.setAccessible(true);
		Person p = Person.getInstance();
		method.invoke(p, new FileInputStream("c:\\1.txt"));
	}
	
	@Test
	//public static void cc(int num)
	public void reflectcc() throws Exception{
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Method method  = clazz.getMethod("cc",int.class);
		method.invoke(null,34535);//静态不传对象也可以
	}
	
	@Test
	//public static void main(String agrs[])
	public void reflectMain()throws Exception{
		Class clazz = Class.forName("cn.moving.reflect.Person");
		Method method  = clazz.getMethod("main", String[].class);
//		method.invoke(null,new String[]{"sdfds","sdfsd"}); //wrong
//		method.invoke(null,(Object)new String[]{"sd2342ds","sdfsd"});//ok
		method.invoke(null,new Object[]{new String[]{"sd2342ds","sdfsd"}});//true
	}
}

注：main方法的参数是一个字符串数组，即publicstaticvoidmain(String[]args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。