在過去的幾次面試中，都被問到了反射這塊的知識，並沒有系統瞭解過Java的反射機制（現實是幾乎怎麼接觸過），所以這方面的問題基本都回答不上來T_T

鎮定思痛，我們來一起好好看看Java中反射的用法。

關於反射的基本用法， http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html  已經有了比較全面的總結，例子也比較豐富，但是有些地方講的也不太對，而且對於內部類的反射並沒有講到。

在獲取多個構造器並用這個構造器建立新例項時用了這樣的例子：

package Reflect;
 
import java.lang.reflect.Constructor;
 
class Person{
     
    public Person() {
         
    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    private String name;
    private int age;
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per1=null;
        Person per2=null;
        Person per3=null;
        Person per4=null;
        //取得全部的建構函式
        Constructor<?> cons[]=demo.getConstructors();
        try{
            per1=(Person)cons[0].newInstance();
            per2=(Person)cons[1].newInstance("Rollen");
            per3=(Person)cons[2].newInstance(20);
            per4=(Person)cons[3].newInstance("Rollen",20);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }
}
 

這是由於獲取到的構造器的順序和原來類中定義的順序不一樣造成的。

在我的機器上，必須按照如下構造器的順序才能正常新建例項：

在查閱了一些資料後我瞭解到JDK對於這個順序並沒有作要求，使用不同版本的JDK獲取的構造器順序可能會有不同，我們寫程式的時候不應該依賴這個順序。

正確的做法是在Class上呼叫帶引數列表的getConstructor()方法來獲取對應的Constructor,再使用這個Constructor來生成新例項。

例如：

            Constructor cons0 = demo.getConstructor();
            Constructor cons1 = demo.getConstructor(String.class);
            Constructor cons2 = demo.getConstructor(int.class);
            Constructor cons3 = demo.getConstructor(String.class,int.class);
             
            Person per1 = (Person) cons0.newInstance();
            Person per2 = (Person) cons1.newInstance("Rollen");
            Person per3 = (Person) cons2.newInstance(20);
            Person per4 = (Person) cons3.newInstance("Rollen", 20);
 

最後是獲取內部類私有成員變數和方法的例子：

package Reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class InnerClassTest {

	public InnerClassTest() {

	}

	public InnerClassTest(String str) {

	}

	class Inner {
		private String name = "Inner";

		public Inner() {
		}

		public Inner(String na) {
			name = na;
		}
		
		private int get(int value){
			return value;
		}
		
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "InnerClass : " + name;
		}
	}

	public static void main(String args[]) {
		try {
			Class c = Class.forName("Reflect.InnerClassTest$Inner");
			if (c != null) {
				Constructor con = c.getDeclaredConstructor(InnerClassTest.class,String.class);
				System.out.println(con.newInstance(new InnerClassTest(),"hello"));
				Method me = c.getDeclaredMethod("get",int.class);
				me.setAccessible(true);
				System.out.println(me.invoke(new InnerClassTest().new Inner(),20));
				Field fe = c.getDeclaredField("name");
				fe.setAccessible(true);
				System.out.println(fe.get(new InnerClassTest().new Inner()));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
 

(非靜態的)內部類的構造方法獲取時比較不一樣，需要傳入外部類物件，同時，在通過獲取的構造器建立例項的時候也需要傳入外部類的例項。

對於靜態的物件和方法，對其呼叫get()或者invoke()方法時第一個引數將會被忽略，我們直接傳入空物件null就可以了。