反射實例講解（框架基礎）

Java反射機制（框架基礎）

JAVA反射機制是在運行狀態中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意方法和屬性；這種動態獲取信息以及動態調用對象方法的功能稱為java語言的反射機制。

通俗易懂的講可以說我們可以通過反射獲得任意一個類或者任意一個對象的所有屬性和方法

class類：普通數據類型 靜態屬性或者方法不是對象屬于類
萬事萬物皆對象
類是Java.lang.Class類的實例對象
任何類都是Class的實例對象

成員變量也是對象，java.lang.reflect.Field Field類封裝了關于成員變量的操作

getName()獲得類的全稱

getMethods()獲得方法

getReturnType()獲得返回類型

getParameterTypes()獲得參數類類型

實際應用案例如下：

案例一：

package fanshe;

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

/**
 * Created by codessl on 2017/9/5 0005.
 */
//成員變量也是對象，java.lang.reflect.Field Field類封裝了關于成員變量的操作
    //getFields getDeclaredFields getType
//getName()獲得類的全稱+getMethods()獲得方法+getReturnType()獲得返回類型+getParameterTypes()獲得參數類類型
public class ClassDemo2 {
    public static void main(String[] args) {
        Class c1=String.class;
        Class c2=void.class;

        System.out.println(c1.getName());//全名
        System.out.println(c2.getSimpleName());//獲取包名之外的類的名稱

        //getMethods()獲得所有的public的函數，包括父類繼承而來的對象
        //getDeclaredMethods()獲取的是所有該類自己聲明的方法，不問訪問權限
        Method[]ms=c1.getMethods();//c.getDeclaredMethods()
        for(int i=0;i<ms.length;i++){
            Class returnType=ms[i].getReturnType();
            System.out.println(returnType.getName());

            //獲得方法名
            System.out.println(ms[i].getName()+"(");
            //獲取參數類型得到參數列表的類型的類類型
            Class[]paramTypes=ms[i].getParameterTypes();
            for(Class class1:paramTypes){
                System.out.println(class1.getName()+",");
            }
            System.out.println(")");
        }


        Field[]fs=c2.getFields();
        for(int i=0;i<fs.length;i++){
            Class fs1=fs[i].getType();
            String name=fs1.getName();//成員變量的類類型

            //獲取成員變量的名稱
            String fieldName=fs[i].getName();
            System.out.println(name+" "+fieldName);
        }
    }
}

案例二：獲取自定義類的相關信息：

package fanshe;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;

/**
 * Created by codessl on 2017/9/5 0005.
 */
public class ReflectMethod {

   public static void main(String args[]) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
       test a = new test();
       Class c = a.getClass();
       Method mt = c.getMethod("printInfo", int.class, int.class);

       //printInfo調用a對象的該方法
       //具有返回值
       Object o= mt.invoke(a, 10,20);
       //都是繞過編譯在運行時進行
       //示例：通過方法的反射繞過泛型
       ArrayList<String>list=new ArrayList<String>();
       int la=123;
       //list.add(la); 編譯時會差生錯誤
       Class listClass=list.getClass();//獲得類類型
       Method limt=listClass.getMethod("add",Object.class);//獲得方法
       Object oo=limt.invoke(list,la);//開始進行反射


       Iterator li=list.iterator();
       while(li.hasNext()){
           System.out.println(li.next());
       }

   }




}

class test {
    public void printInfo(int a, int b) {
        System.out.println(a + "," + b);
    }
}

案例三：

（1）Fool類的創建

package fanshe;

/**
 * Created by codessl on 2017/9/5 0005.
 */
public class Fool {
}

（2）調用

package fanshe;

/**
 * Created by codessl on 2017/9/5 0005.
 */
public class Reflect {
    public static void main(String[] args) {
       Fool fool=new Fool();
       //Foool也是個實例對象，Class類的實例對象，
        //任何一個類都是Class類的實例對象，這個對象有三種表示方式

        //任何一個類都有一個隱含的靜態變量Class，適用于知道類時的情況
        Class c1=Fool.class;

        //第二種表達方式，已知該類的對象通過getClass方法獲取 知道類對象
        Class c2=fool.getClass();
        //類也是對象被稱為class的實例對象，這個對象被稱為該類的類類型

        //c1 c2代表Fool類的類類型 其他的為其實例對象
        System.out.println(c1==c2);

        Class c3=null;
        try {
            c3=Class.forName("fanshe.Fool");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c2==c3);

        //Class.forName("類的全稱")動態加載類
        //編譯時靜態加載類，運行時動態加載類
        //由類類型得實例對象+無參數構造方法
        try {
            Fool newfool=(Fool)c1.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}