關於反射的一些姿勢

獲取Class對象有三種方式：

 

1.通過Object類的getClass()方法。例如：

Class c1 = new String("").getClass();

2.通過Class類的靜態方法——forName()來實現：

Class c2 = Class.forName("MyObject");

3.如果T是一個已定義的類型的話，在java中，它的.class文件名：T.class就代表了與其匹配的Class對象，例如：

Class c3 = Manager.class;

Class c4 = int.class;

Class c5 = Double[].class;

Class類中存在以下幾個重要的方法：

 

1.getName()

一個Class對象描述了一個特定類的特定屬性，而這個方法就是返回String形式的該類的簡要描述。由於歷史原因，對數組的Class對象

調用該方法會產生奇怪的結果。

2.newInstance()

該方法可以根據某個Class對象產生其對應類的實例。需要強調的是，它調用的是此類的默認構造方法。例如：

MyObject x = new MyObject();

MyObject y = x.getClass().newInstance();

3.getClassLoader()

返回該Class對象對應的類的類加載器。

 

4.getComponentType()

該方法針對數組對象的Class對象，可以得到該數組的組成元素所對應對象的Class對象。例如：

int[] ints = new int[]{1,2,3};

Class class1 = ints.getClass();

Class class2 = class1.getComponentType();

而這裏得到的class2對象所對應的就應該是int這個基本類型的Class對象。

 

5.getSuperClass()

返回某子類所對應的直接父類所對應的Class對象。

 

6.isArray()

判定此Class對象所對應的是否是一個數組對象。

反射就是讓你可以通過名稱來得到對象(類，屬性，方法)的技術。

反射是松耦合，靈活性高，動態加載的;引用是緊耦合

動態地獲取類的一切信息，並利用這些信息做一些你想做的事情 

 Object str=cls_str.newInstance(); //相當於String str=new String(); //通過方法名來調用 一個方法 String methodName = \"length \"; Method m=cls_str.getMethod(methodName,null); System.out.println(\"lengthis \"+m.invoke(str,null)); //相當於System.out.println(str.length()); 上面的兩個例子是比 較常用方法。看到上面的例子就有人要發問了：爲什麼要這麼麻煩呢？本來一條語句就完成的事情幹嗎要整這麼複雜？沒錯，在上面的例子中確實沒有必要這麼麻 煩。不過你想像這樣一個應用程序，它支持動態的功能擴展，也就是說程序不重新啓動但是可以自動加載新的功能，這個功能使用一個具體類來表示。首先我們必須 爲這些功能定義一個接口類，然後我們要求所有擴展的功能類必須實現我指定的接口，這個規定了應用程序和可擴展功能之間的接口規則，但是怎麼動態加載呢？我 們必須讓應用程序知道要擴展的功能類的類名，比如是test.Func1，當我們把這個類名(字符串)告訴應用程序後，它就可以使用我們第一個例子的方法 來加載並啓用新的功能。這就是類的反射，請問你有別的選擇嗎？ 

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

 

public class ReflectionTest {

    public static void main(String[] args) {

        Class c=null;

        try {

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

            System.out.println("package "+c.getPackage().getName()+";");

            System.out.print(Modifier.toString(c.getModifiers())+" ");

            System.out.print("class "+c.getSimpleName()+" ");

            if (c.getSuperclass()!=Object.class) {

                System.out.print("extends " + c.getSuperclass().getSimpleName());

            }

            Class[] inters=c.getInterfaces();

            if(inters.length>0){

                System.out.print("implements ");

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

                    System.out.print(inters[i].getSimpleName());

                    if(i<inters.length-1){

                        System.out.print(",");

                    }

                }

            }

            System.out.println("{");

            printFields(c);

            printMethods(c);

            System.out.println("}");

        } catch (ClassNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

             

    }

    public static void printFields(Class c){

        Field[] field=c.getDeclaredFields();

        if(field.length>0){

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

                System.out.println(Modifier.toString(field[i].getModifiers())+" "+field[i].getType().getSimpleName()+" "+field[i].getName()+";");

            }

        }

    }

    public static void printMethods(Class c){

        Method[] method=c.getDeclaredMethods();

        if(method.length>0){

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

                Class[] parameter=method[i].getParameterTypes();

                System.out.print(Modifier.toString(method[i].getModifiers())+" "+method[i].getReturnType().getSimpleName()+" "+method[i].getName()+"(");

                for(int j=0;j<parameter.length;j++){

                    System.out.print(parameter[j].getSimpleName()+" args");

                    if(j!=parameter.length-1){

                        System.out.print(",");

                    }

                }

                System.out.print(") ");

                Class exception[]=method[i].getExceptionTypes();

                 

                if (exception.length>0) {

                    System.out.print("throws ");

                    for (int j = 0; j < exception.length; j++) {

                        System.out.print(exception[j].getSimpleName());

                    }

                }

                System.out.println("{");

                System.out.println("\t... ...");

                System.out.println("}");

            }

             

        }

    }

}







// 反射動態執行方法

public class ReflectTest {

     

    public int Add(int x, int y){

        System.out.println(x + y);

        return x + y;

    }

     

    public String echo(String str) {

        System.out.println("Hello, " + str);

        return "Hello, " + str;

    }

 

    public static void main(String[] args) throws  NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Class<?> classType = ReflectTest.class;

        Object obj = classType.newInstance();   

         

        Method method = classType.getMethod("Add", new Class[]{int.class, int.class});

        method.invoke(obj, new Object[] {new Integer(100),new Integer(200)} );

         

        Method method2 = classType.getMethod("echo", new Class[] {String.class});

        method2.invoke(obj, new Object[] {"world"});

         

 

    }

 

}