Java反射機制深入詳解，java反射詳解

Java反射機制深入詳解，java反射詳解
一.概念

　　反射就是把Java的各種成分映射成相應的Java類。

　　Class類的構造方法是private，由JVM建立。

　　反射是java語言的一個特性，它允程式在運行時（注意不是編譯的時候）來進行自我檢查並且對內部的成員進行操作。例如它允許一個java的類擷取他所有的成員變數和方法並且顯示出來。Java 的這一能力在實際應用中也許用得不是很多，但是在其它的程式設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程式中獲得函數定義相關的資訊。 （來自Sun）

　　JavaBean 是 reflection 的實際應用之一，它能讓一些工具可視化的操作軟體組件。這些工具通過 reflection 動態載入並取得 Java 組件(類) 的屬性。

　　反射是從1.2就有的，後面的三大架構都會用到反射機制,涉及到類"Class",無法直接new CLass()，其對象是記憶體裡的一份位元組碼.　　

　　Class 類的執行個體表示正在啟動並執行 Java 應用程式中的類和介面。枚舉是一種類，注釋是一種介面。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共用該 Class 對象。基本的 Java類型（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示為 Class 對象。Class 沒有公用構造方法。Class 對象是在載入類時由 JAVA 虛擬機器以及通過調用類載入器中的 defineClass 方法自動構造的。　

1 Person p1 = new Person();
2 //下面的這三種方式都可以得到位元組碼
3 CLass c1 = Date.class();
4 p1.getClass(); 5 //若存在則載入，否則建立,往往使用第三種,類的名字在寫來源程式時不需要知道，到運行時再傳遞過來
6 Class.forName("java.lang.String");

　　CLass.forName()位元組碼已經載入到java虛擬機器中，去得到位元組碼；java虛擬機器中還沒有產生位元組碼 用類載入器進行載入，載入的位元組碼緩衝到虛擬機器中。　

　　考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。

import java.lang.reflect.*;  

public class DumpMethods {  

   public static void main(String args[]) {  

      try {  

           Class c = Class.forName("java.util.Stack");  

           Method m[] = c.getDeclaredMethods();  

             

           for (int i = 0; i < m.length; i++)  

               System.out.println(m[i].toString());  

      }  

      catch (Throwable e){  

            System.err.println(e);  

      }  

   }  

}

 

1 public synchronized java.lang.Object java.util.Stack.pop() 2 public java.lang.Object java.util.Stack.push(java.lang.Object) 3 public boolean java.util.Stack.empty() 4 public synchronized java.lang.Object java.util.Stack.peek() 5 public synchronized int java.util.Stack.search(java.lang.Object)

　　這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和傳回型別。這個程式使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來擷取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。

　　以下樣本使用 Class 對象來顯示對象的類名：

1 void printClassName(Object obj) {
2          System.out.println("The class of " + obj +
3                             " is " + obj.getClass().getName());
4      }

　　還可以使用一個類字面值（JLS Section 15.8.2）來擷取指定類型（或 void）的 Class 對象。例如：

1 System.out.println("The name of class Foo is: "+Foo.class.getName());

 　　在沒有對象執行個體的時候，主要有兩種辦法。

//獲得類類型的兩種方式        

Class cls1 = Role.class;        

Class cls2 = Class.forName("yui.Role");

　　注意第二種方式中，forName中的參數一定是完整的類名（包名+類名），並且這個方法需要捕獲異常。現在得到cls1就可以建立一個Role類的執行個體了，利用Class的newInstance方法相當於調用類的預設的構造器。

1 Object o = cls1.newInstance(); 2 //建立一個執行個體        
3 //Object o1 = new Role();   //與上面的方法等價

二.常用方法　　

　　1.isPrimitive(判斷是否是基本類型的位元組碼)

public class TestReflect {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        String str = "abc";

        Class cls1 = str.getClass();

        Class cls2 = String.class;

        Class cls3 = null;//必須要加上null

        try {

            cls3 = Class.forName("java.lang.String");

        } catch (ClassNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        System.out.println(cls1==cls2);

        System.out.println(cls1==cls3);

        

        System.out.println(cls1.isPrimitive());

        System.out.println(int.class.isPrimitive());//判定指定的 Class 對象是否表示一個基本類型。

        System.out.println(int.class == Integer.class);

        System.out.println(int.class == Integer.TYPE);

        System.out.println(int[].class.isPrimitive());

        System.out.println(int[].class.isArray());

    }

}

/*

 * true

true

false

true

false

true

false

true

 */

*/

　　2.getConstructor和getConstructors()

　　java中構造方法沒有先後順序，通過類型和參數個數區分。　

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException {

        // TODO Auto-generated method stub

        String str = "abc";

        

        System.out.println(String.class.getConstructor(StringBuffer.class));

    }

}

　　3.Filed類代表某一類中的一個成員變數。

import java.lang.reflect.Field;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        ReflectPointer rp1 = new ReflectPointer(3,4);

        Field fieldx = rp1.getClass().getField("x");//必須是x或者y

        System.out.println(fieldx.get(rp1));

        

        /*

         * private的成員變數必須使用getDeclaredField，並setAccessible(true),否則看得到拿不到

         */

        Field fieldy = rp1.getClass().getDeclaredField("y");

        fieldy.setAccessible(true);//暴力反射

        System.out.println(fieldy.get(rp1));

        

    }

}

class ReflectPointer {

    

    public int x = 0;

    private int y = 0;

    

    public ReflectPointer(int x,int y) {//alt + shift +s相當於右鍵source

        super();

        // TODO Auto-generated constructor stub

        this.x = x;

        this.y = y;

    }

}

三.典型例題

　　1.將所有String類型的成員變數裡的b改成a。

import java.lang.reflect.Field;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        ReflectPointer rp1 = new ReflectPointer(3,4);

        changeBtoA(rp1);

        System.out.println(rp1);

        

    }

    

    private static void changeBtoA(Object obj) throws RuntimeException, Exception {

        Field[] fields = obj.getClass().getFields();

        

        for(Field field : fields) {

            //if(field.getType().equals(String.class))

            //由於位元組碼只有一份,用equals語義不準確

            if(field.getType()==String.class) {

                String oldValue = (String)field.get(obj);

                String newValue = oldValue.replace('b', 'a');

                field.set(obj,newValue);

            }

        }

    }

}

class ReflectPointer {

    

    private int x = 0;

    public int y = 0;

    public String str1 = "ball";

    public String str2 = "basketball";

    public String str3 = "itcat";

    

    public ReflectPointer(int x,int y) {//alt + shift +s相當於右鍵source

        super();

        // TODO Auto-generated constructor stub

        this.x = x;

        this.y = y;

    }

    @Override

    public String toString() {

        return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="

                + str3 + "]";

    }

}

　　2.寫一個程式根據使用者提供的類名，調用該類的裡的main方法。

　　為什麼要用反射的方式呢？

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        String str = args[0];

        /*

         * 這樣會數組角標越界，因為壓根沒有這個字元數組

         * 需要右鍵在run as-configurations-arguments裡輸入b.Inter（完整類名）

         * 

         */

        Method m = Class.forName(str).getMethod("main",String[].class);

        //下面這兩種方式都可以,main方法需要一個參數

        

        m.invoke(null, new Object[]{new String[]{"111","222","333"}});

        m.invoke(null, (Object)new String[]{"111","222","333"});//這個可以說明，數組也是Object

        /*

         * m.invoke(null, new String[]{"111","222","333"})

         * 上面的不可以,因為java會自動拆包

         */

    }

}

class Inter {

    public static void main(String[] args) {

        for(Object obj : args) {

            System.out.println(obj);

        }

    }

}

　　3.類比 instanceof 操作符

class S {  

}   

public class IsInstance {  

   public static void main(String args[]) {  

      try {  

           Class cls = Class.forName("S");  

           boolean b1 = cls.isInstance(new Integer(37));  

           System.out.println(b1);  

           boolean b2 = cls.isInstance(new S());  

           System.out.println(b2);  

      }  

      catch (Throwable e) {  

           System.err.println(e);  

      }  

   }  

}

　　在這個例子中建立了一個S 類的 Class 對象，然後檢查一些對象是否是S的執行個體。Integer(37) 不是，但 new S()是。

四.Method類

　　代表類（不是對象）中的某一方法。

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/*

 * 人在黑板上畫圓，涉及三個對象,畫圓需要圓心和半徑，但是是私人的，畫圓的方法

 * 分配給人不合適。

 * 

 * 司機踩刹車，司機只是給列車發出指令，刹車的動作還需要列車去完成。

 * 

 * 面試經常考物件導向的設計，比如人關門，人只是去推門。

 * 

 * 這就是專家模式：誰擁有資料，誰就是專家,方法就分配給誰

 */

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        String str = "shfsfs";

        //包開頭是com表示是sun內部用的，java打頭的才是使用者的

        Method mtCharAt = String.class.getMethod("charAt", int.class);

        Object ch = mtCharAt.invoke(str,1);//若第一個參數是null，則肯定是靜態方法

        System.out.println(ch);

        

        System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4文法

        

    }

    

}

五.數組的反射

　　Array工具類用於完成數組的反射操作。

　　同類型同緯度有相同的位元組碼。

　　int.class和Integer.class不是同一份位元組碼，Integer.TYPE，TYPE代表封裝類對應的基本類的位元組碼    int.class==Integer.TYPE

import java.util.Arrays;

/*

 * 從這個例子看出即便位元組碼相同但是對象也不一定相同,根本不是一回事

 * 

 */

public class TestReflect {

    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {

        int[] a = new int[3];

        int[] b = new int[]{4,5,5};//直接賦值後不可以指定長度，否則ＣＥ

        int[][] c = new int[3][2];

        String[] d = new String[]{"jjj","kkkk"};

        System.out.println(a==b);//false

        System.out.println(a.getClass()==b.getClass());//true

        //System.out.println(a.getClass()==d.getClass());    //比較位元組碼a和cd也沒法比

        System.out.println(a.getClass());//輸出class [I

        System.out.println(a.getClass().getName());//輸出[I,中括弧表示數組，I表示整數

        

        System.out.println(a.getClass().getSuperclass());//輸出class java.lang.Object

        System.out.println(d.getClass().getSuperclass());//輸出class java.lang.Object

        

        //由於父類都是Object,下面都是可以的

        Object obj1 = a;//不可是Object[]

        Object obj2 = b;

        Object[] obj3 = c;//基本類型的一位元組只可以當做Object，非得還可以當做Object[]

        Object obj4 = d;

        

        //注意asList處理int[]和String[]的區別

        System.out.println(Arrays.asList(b));//1.4沒有可變參數，使用的是數組,[[I@1bc4459]

        System.out.println(Arrays.asList(d));//[jjj, kkkk]

        

    }

}

六.結束語

　　以上就是反射機制的簡單的使用，顯然學過spring的朋友一定明白了，為什麼可以通過設定檔就可以讓我們獲得指定的方法和變數，在我們建立對象的時候都是通過傳進string實現的，就好像你需要什麼，我們去為你生產，還有我們一直在用Object,這就說明java語言的動態特性，依賴性大大的降低了。

如果你在學習Java的過程中遇見什麼問題或者想擷取學習資源的話歡迎加入團長的Java學習交流QQ群：618528494

群內禁止閑聊 ，名額有限，非喜勿進。

• http://www.cnblogs.com/hxsyl/archive/2013/03/23/2977593.html

Java團長

號：javatuanzhang

每日分享Java技術乾貨

長按識別二維碼