java的反射机制：
我们都知道，一个java类中，有成员变量、成员方法、构造方法等等，反射机制，就是动态的获取这些类中的信息，并动态的调用对象的方法。通常只有要设计框架的过程中，才会使用java反射相关的api，但是了解java反射机制的基本原理与基本方法，可以帮忙我们在日后对框架的学习与应用提供很大的帮忙。
了解Class类：
Class类代表着某个类的字节码，要使用反射，就需要取得对应的Class对象，然后就通过这个对象，就可解剖出类的成员变量，成员方法等等。
Class类的常用方法：
getConstructor() 获取构造函数
getMethod() 获取成员方法
getField() 获取成员变量
getDeclaredConstructor() 获取私有的构造函数
getDeclaredMethod() 获取私有的成员方法
getDeclaredField() 获取私有的成员变量
如何获取Class类对象：
[java]
//通过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类：
[java]
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);
}
}
构造函数的获取：
[java]
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);
}
}
成员方法的获取：
[java]
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++"});
}
}
成员属性的获取：
[java]
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);
}
}
}
