java的反射技术

     java的反射机制：

          我们都知道，一个java类中，有成员变量、成员方法、构造方法等等，反射机制，就是动态的获取这些类中的信息，并动态的调用对象的方法。通常只有要设计框架的过程中，才会使用java反射相关的api，但是了解java反射机制的基本原理与基本方法，可以帮忙我们在日后对框架的学习与应用提供很大的帮忙。

     了解Class类：

          Class类代表着某个类的字节码，要使用反射，就需要取得对应的Class对象，然后就通过这个对象，就可解剖出类的成员变量，成员方法等等。

  Class类的常用方法：

  getConstructor() 获取构造函数

  getMethod()  获取成员方法

  getField() 获取成员变量

   

  getDeclaredConstructor() 获取私有的构造函数

  getDeclaredMethod()  获取私有的成员方法

  getDeclaredField() 获取私有的成员变量

     如何获取Class类对象：

		//通过Class的forName()方法,此方法最为常用
		Class class1 = Class.forName("com.java4fun.reflect.Person");
		//通过 Person.class
		Class class2 = Person.class;
		//通过对象获得
		Class class3 = new Person().getClass();

反射的使用，简单的讲，就是通过类的Class对象，获取对应的Field、Method 和 Constructor 对象，并进行相关操作。

下面就用反射来解剖Person类，给出Person类：

public class Person {
	
	public String name = "java";
	private int age = 2013;
	
	//无参构造函数
	public Person() {
	}
	
	public Person(int age) {
		super();
		this.age = age;
	}
	//私有构造函数
	private Person(String name) {
		super();
		this.name = name;
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public String getName() {
		return name;
	}

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

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

	public static void getMessage(String message){
		System.out.println(message);
	}
	
	public static void getFriends(String friends[]){
		for(String s:friends){
			System.out.print(s+"\t");
		}
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	private void secret(String secret){
		System.out.println(secret);
	}
	
	public void run(int num){
		System.out.println(num);
	}
}

构造函数的获取：

import java.lang.reflect.Constructor;

public class ConstructorTest {
	// 利用反射技术，完成对Person.类的相关操作
	public static void main(String[] args) throws Exception {
		 constructor1(); //无参构造函数的获取与使用
		 constructor2(); // 带参数的构造函数的获取使用
		 constructor3(); // 私有的构造函数的获取使用
	}

	// 获取私有构造函数
	private static void constructor3() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取私有构造函数对象。
		Constructor c = clazz.getDeclaredConstructor(String.class);
		// 由于私有的构造函数无数直接构造对象,需要调用setAccessible()，
		//此方法来自于AccessibleObject 类，它是 Field、Method 和 Constructor 对象的基类
		c.setAccessible(true);
		// 利用这个构造函数，构造一个Person对象
		Person p = (Person) c.newInstance("private constructor");
		System.out.println(p);
	}

	// 访问带参数的构造函数
	private static void constructor2() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取带参数的构造函数对象。
		Constructor c = clazz.getConstructor(String.class, int.class);
		// 利用这个构造函数，构造一个Person对象
		Person p = (Person) c.newInstance("hello", 110);
		System.out.println(p);
	}

	// 访问无参构造函数
	private static void constructor1() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取无参的构造函数对象。
		Constructor c = clazz.getConstructor(null);
		// 利用这个构造函数，构造一个Person对象
		Person p = (Person) c.newInstance(null);
		System.out.println(p);

		// Class类也提供了一个可直接用无参构造函数构造对象的方法
		// Person person = (Person) clazz.newInstance();
		// System.out.println(person);
	}
}

成员方法的获取：

import java.lang.reflect.Method;

public class MethodTest {
	// 利用反射技术，完成对Person.类的相关操作
	public static void main(String[] args) throws Exception {
		 //method1(); //无参成员方法的获取与使用
		// method2(); // 带参数成员方法的获取使用
		 //method3(); // 私有成员方法的获取使用
		method4(); // 参数是数组的方法解决方法
	}

	// 获取无参成员方法
	private static void method1() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取无参的方法， 反射Person类的中 public String getName(){}方法
		Method m = clazz.getMethod("getName", null);
		//运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
		Person p = new Person("HelloWorld",23);
		String name = (String) m.invoke(p, null);
		System.out.println(name);
	}
	
	// 获取带参数的成员方法
	private static void method2() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取带参数的方法， 反射Person类的中 public void run(int num){}方法
		Method m = clazz.getMethod("run", int.class);
		//运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
		Person p = new Person("HelloWorld",23);
		m.invoke(p, 11111);
	}
	
	// 获取私有的成员方法
	private static void method3() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获私有的方法， 反射Person类的中 private void secret(String secret){}方法
		Method m = clazz.getDeclaredMethod("secret", String.class);
		//让私有方法可以访问
		m.setAccessible(true);
		//运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
		Person p = new Person("HelloWorld",23);
		m.invoke(p, "最近变胖了");
	}

	// 参数是数组的方法解决方法
	private static void method4() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获静态方法， 反射Person类的中 public static void getFriends(String friends[]){}方法
		Method m = clazz.getMethod("getFriends", String[].class);
		
		//这样调用方法会出错，由于版本的遗留问题，new String[]{"java","c","c++"}会被认为是"java" "c"  "c++"
		//m.invoke(null, new String[]{"java","c","c++"});
		//相当于getFriends("java","c","c++");
		
		//正确调用方法,相当于把数组当成一个对象传入
		m.invoke(null, (Object)new String[]{"java","c","c++"});
	}
}

成员属性的获取：

import java.lang.reflect.Field;

public class FieldTest {
	// 利用反射技术，完成对Person.类的相关操作
	public static void main(String[] args) throws Exception {
		 method1(); // 获取属性
		 method2(); // 获取私有属性
	}

	// 获取属性
	private static void method1() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取属性， 反射Person类的中 public String name = "java";属性
		Field f = clazz.getField("name");
		// 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。
		Person p = new Person();
		Class type = f.getType();
		if (type.equals(String.class)) {
			String name = (String) f.get(p);
			System.out.println(name);
		}
	}

	// 获取私有属性  
	private static void method2() throws Exception {
		// 获取Person的字节码对象。
		Class clazz = Class.forName("com.java4fun.reflect.Person");
		// 获取私有属性， 反射Person类的中 private int age = 2013;属性
		Field f = clazz.getDeclaredField("age");
		f.setAccessible(true);
		// 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。
		Person p = new Person();
		Class type = f.getType();
		if (type.equals(int.class)) {
			int age = f.getInt(p);
			System.out.println(age);
		}
	}
}