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);
}
}
}