一，先看一下反射的概念：

JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法；這種動態獲取的資訊以及動態呼叫物件的方法的功能稱為java語言的反射機制。

Java反射機制主要提供了以下功能： 在執行時判斷任意一個物件所屬的類；在執行時構造任意一個類的物件；在執行時判斷任意一個類所具有的成員變數和方法；在執行時呼叫任意一個物件的方法；生成動態代理。

二，反射機制的作用：

              1，反編譯：.class-->.java

              2,通過反射機制訪問java物件的屬性，方法，構造方法等；

這樣好像更容易理解一些，下邊我們具體看怎麼實現這些功能。

三，在這裡先看一下sun為我們提供了那些反射機制中的類：

java.lang.Class;                

java.lang.reflect.Constructor; java.lang.reflect.Field;        

java.lang.reflect.Method;

java.lang.reflect.Modifier;

很多反射中的方法，屬性等操作我們可以從這四個類中查詢。還是哪句話要學著不斷的查詢API，那才是我們最好的老師。

四，具體功能實現：

                1

1. //第一種方式：
2. Classc1 = Class.forName("Employee");  
3. //第二種方式：
4. //java中每個型別都有class 屬性.
5. Classc2 = Employee.class;  
6. //第三種方式：
7. //java語言中任何一個java物件都有getClass 方法
8. Employeee = new Employee();  
9. Classc3 = e.getClass(); //c3是執行時類 (e的執行時類是Employee)

    2，建立物件：獲取類以後我們來建立它的物件，利用

1. Class c =Class.forName("Employee");  
2. //建立此Class 物件所表示的類的一個新例項
3. Objecto = c.newInstance(); //呼叫了Employee的無引數構造方法.

    3,獲取屬性：分為所有的屬性和指定的屬性：

      a，先看獲取所有的屬性的寫法：

1. //獲取整個類
2.             Class c = Class.forName("java.lang.Integer");  
3.               //獲取所有的屬性?
4.             Field[] fs = c.getDeclaredFields();  
5.                    //定義可變長的字串，用來儲存屬性
6.             StringBuffer sb = new StringBuffer();  
7.             //通過追加的方法，將每個屬性拼接到此字串中
8.             //最外邊的public定義
9.             sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
10.             //裡邊的每一個屬性
11.             for(Field field:fs){  
12.                 sb.append("\t");//空格
13.                 sb.append(Modifier.toString(field.getModifiers())+" ");//獲得屬性的修飾符，例如public，static等等
14.                 sb.append(field.getType().getSimpleName() + " ");//屬性的型別的名字
15.                 sb.append(field.getName()+";\n");//屬性的名字+回車
16.             }  
17.             sb.append("}");  
18.             System.out.println(sb);  

1. publicstaticvoid main(String[] args) throws Exception{  
2. <span style="white-space:pre">  </span>//以前的方式：
3.     /* 
4.     User u = new User(); 
5.     u.age = 12; //set 
6.     System.out.println(u.age); //get 
7.     */
8.     //獲取類
9.     Class c = Class.forName("User");  
10.     //獲取id屬性
11.     Field idF = c.getDeclaredField("id");  
12.     //例項化這個類賦給o
13.     Object o = c.newInstance();  
14.     //打破封裝
15.     idF.setAccessible(true); //使用反射機制可以打破封裝性，導致了java物件的屬性不安全。
16.     //給o物件的id屬性賦值"110"
17.     idF.set(o, "110"); //set
18.     //get
19.     System.out.println(idF.get(o));  
20. }  

 4，獲取方法，和構造方法，不再詳細描述，只來看一下關鍵字：

方法關鍵字	含義
getDeclaredMethods()	獲取所有的方法
getReturnType()	獲得方法的放回型別
getParameterTypes()	獲得方法的傳入引數型別
getDeclaredMethod("方法名",引數型別.class,……)	獲得特定的方法
構造方法關鍵字	含義
getDeclaredConstructors()	獲取所有的構造方法
getDeclaredConstructor(引數型別.class,……)	獲取特定的構造方法
父類和父介面	含義
getSuperclass()	獲取某類的父類
getInterfaces()	獲取某類實現的介面

這樣我們就可以獲得類的各種內容，進行了反編譯。對於JAVA這種先編譯再執行的語言來說，反射機制可以使程式碼更加靈活，更加容易實現面向物件。

五，反射加配置檔案，使我們的程式更加靈活：

在設計模式學習當中，學習抽象工廠的時候就用到了反射來更加方便的讀取資料庫連結字串等，當時不是太理解，就照著抄了。看一下.NET中的反射+配置檔案的使用：

當時用的配置檔案是app.config檔案，內容是XML格式的，裡邊填寫連結資料庫的內容:

1. <configuration>
2. lt;appSettings>
3. <addkey=""value=""/>
4. lt;/appSettings>
5.         </configuration>

反射的寫法：

1. assembly.load("當前程式集的名稱").CreateInstance("當前名稱空間名稱".要例項化的類名);  

這樣的好處是很容易的方便我們變換資料庫，例如我們將系統的資料庫從SQL Server升級到Oracle，那麼我們寫兩份D層，在配置檔案的內容改一下，或者加條件選擇一下即可，帶來了很大的方便。

當然了，JAVA中其實也是一樣，只不過這裡的配置檔案為.properties,稱作屬性檔案。通過反射讀取裡邊的內容。這樣程式碼是固定的，但是配置檔案的內容我們可以改，這樣使我們的程式碼靈活了很多！

    綜上為，JAVA反射的再次學習，靈活的運用它，能夠使我們的程式碼更加靈活，但是它也有它的缺點，就是運用它會使我們的軟體的效能降低，複雜度增加，所以還要我們慎重的使用它。