寫在前面

今天在需求評審的時候，遇到了挺有意思的要求。需求是什麼樣子就不說了。總之完成這個需求需要一個呼叫系統api的操作。然而這個api因為並不穩定的原因。被谷歌hide掉了。
這個時候我們最直接的方式就是去通過反射去呼叫這個系統api。（當然這種方式治標不治本，因為既然被hide，就說明這個api很不穩定。所以這個版本可以用，有可能下個版本就沒了）
不過這裡我們不考慮這個問題，因為如題所說，這次主角是反射。
之前在用反射的時候，其實並沒有過去思考反射所帶來的東西。而這次在用反射的時候，自己多少加入了思考。
我在看JVM的時候：瞭解到一個概念，那就是我們在new一個物件的時候，JVM會先使用雙親委派機制去載入這個class物件，這個class物件會唯一的被加載出來。然後才是我們的例項物件建立到堆中。
之前我去上述的理解沒有任何概念，僅僅是當做文字給記了下來。直到我幾天再使用反射的時候，突然對上述的概念有了實質性的認識。
不過不著急，讓我們一點點的深入….

反射的使用

首先我們先宣告一個物件：

我是一個android彩筆開發，因此這裡的日誌使用了Log，而非是System.out.print。各位看官想看效果，可以換成自己熟悉的即可。

public class ReflectModel {
    private ReflectBean mReflectBean;
    private String mContent = "A";
    public int mNum = 1;
    public static int sNum = 666;

    public ReflectModel() {
        LogUtils.d(TAG, "ReflectModel()，無參構造方法執行"
 
);
    }

    public ReflectModel(String content) {
        LogUtils.d(TAG, "ReflectModel(String content)，一個String引數的構造方法執行");
        mContent = content;
    }

    private ReflectModel(String content, int num) {
        LogUtils.d(TAG, "ReflectModel(String content,int num)，倆個引數的私有構造方法執行");
        mContent = content;
        mNum = num;
    }

    public
 
 void fun() {
        LogUtils.d(TAG, "我就是一個方法，在本例子中。我是被反射生成的物件呼叫的->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void printContent() {
        LogUtils.d(TAG, "我就是私有的列印方法->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void setContent(String content) {
        LogUtils.d(TAG, "我就是一個帶有一個String引數的私有方法->setContent:" + content);
        mContent = content;
    }

    public void printBean() {
        LogUtils.d(TAG, "我是ReflectBean的列印方法->mName:" + mReflectBean.getName());
    }

    public static void staticFun() {
        LogUtils.d(TAG, "我是靜態方法staticFun");
    }
}

ReflectBean

public class ReflectBean {
    private String mName = "a";

    public ReflectBean(String name) {
        mName = name;
    }

    public String getName() {
        return mName;
    }
}

反射的使用：

public void fun() {
        //第一種方式獲取Class物件：產生一個Student物件的例項，以及一個唯一的Class物件。
        ReflectModel model1 = new ReflectModel();
        //獲取Class物件：這種方式沒什麼意義，既然有了物件的例項，何必再去反射
        Class modelClass = model1.getClass();

        //第二種方式獲取Class物件：需要我們導包，但是有些時候這個類是隱藏的（比如很多系統不穩定的類，@Hide）
        Class modelClass2 = ReflectModel.class;

        Class modelClass3 = null;
        try {
            //第三種方式獲取Class物件：類的全路徑
            modelClass3 = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectModel");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //開始進行具體內部操作，此時我們僅僅是拿到了ReflectModel的class這個物件，而非是這個ReflectModel物件的例項
        if (modelClass3 != null) {
            //獲取ReflectModel.class對應的所有構造方法(public的)
            Constructor[] constructors = modelClass3.getConstructors();
            for (Constructor constructor : constructors) {
                LogUtils.d(TAG, "當前獲取的構造方法：" + constructor.getName());
            }
            LogUtils.d(TAG, "----以上是public的----");
            //所有構造方法(包括：私有、受保護、預設、公有)
            constructors = modelClass3.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                LogUtils.d(TAG, "當前獲取的構造方法：" + constructor);
            }

            Object object = null;
            try {
                // 獲取共有無參建構函式
                Constructor con = modelClass3.getConstructor(null);
                // 呼叫此無參構造方法，那麼此時我們就會獲取到Reflect的例項物件了(預設返回object)
                ReflectModel reflectModel = (ReflectModel) con.newInstance();
                // 有了ReflectModel物件例項，我們就可以正常使用了
                /**
                 * 但是此時我們知道，我們強制型別轉成了我們想要的型別，但是我們上文中提到，有些類是hide的。
                 * 因此我們很多情況下，我們被限制只能得到object物件。
                 */
                reflectModel.fun();
                // 獲取私有的含有String和int引數的構造方法
                con = modelClass3.getDeclaredConstructor(new Class[]{String.class, int.class});
                // 此時我們獲取到了這個private的含參構造方法物件，但是因為private許可權原因，我們沒辦法直接呼叫newInstance()
                // 我們需要呼叫下面的方法，無視private修飾符（呼叫後，我們就可以執行private的構造方法）
                con.setAccessible(true);
                //呼叫私有倆參構造方法
                object = con.newInstance("B", 2);


                /**
                 * 反射呼叫方法
                 */
                //上訴提到，如果我們反射的類是hide，此時我們肯定沒辦法把Object轉成ReflectModel型別。因此，我們拿到這個例項後想要呼叫其方法，還需要使用反射的方式
                // private方法應該使用getDeclaredMethod()去獲取
                Method printContent = modelClass3.getDeclaredMethod("printContent", new Class[]{});
                //同樣因為private的原因，我們在執行方法時，要先清除許可權問題
                printContent.setAccessible(true);
                //使用object例項物件，呼叫printContent方法，因為沒有引數，所以傳null
                printContent.invoke(object, null);
                //生成名為setContent的含有一個String引數的方法物件
                Method setContent = modelClass3.getDeclaredMethod("setContent", new Class[]{String.class});
                setContent.setAccessible(true);
                //呼叫setContent方法，去改變mContent的值
                setContent.invoke(object, "C");
                //再次執行列印操作
                printContent.invoke(object, null);

                //呼叫靜態方法
                Method staticMethod = modelClass3.getMethod("staticFun", new Class[]{});
                //因為靜態方法屬於類，所以我們不需要傳例項物件，因為它在class被載入的時候，就已經被建立了。
                staticMethod.invoke(null, null);


                /**
                 * 反射呼叫變數
                 */
                //獲取所有public變數封裝的Field物件
                Field[] fields = modelClass3.getFields();
                //獲取所有變數封裝的Field物件
                fields = modelClass3.getDeclaredFields();

                //獲取private的mContent的變數
                Field content = modelClass3.getDeclaredField("mContent");
                content.setAccessible(true);
                Field num = modelClass3.getField("mNum");
                num.set(object, 3);
                //獲取static變數
                Field sNum = modelClass3.getField("sNum");
                LogUtils.d(TAG, "mNum在object例項物件中的值:" + num.get(object) + "-static變數sNum的值:" + sNum.get(null));
                //將object例項的mContent物件，設定為D
                content.set(object, "D");
                printContent.invoke(object, null);

                Field reflectBean = modelClass3.getDeclaredField("mReflectBean");
                Class reflectBeanClass = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectBean");
                Constructor beanCon = reflectBeanClass.getConstructor(new Class[]{String.class});
                Object beanObject = beanCon.newInstance("b");
                //給mReflectBean賦值
                reflectBean.setAccessible(true);
                reflectBean.set(object, beanObject);
                Method printBean = modelClass3.getMethod("printBean", new Class[]{});
                printBean.invoke(object, null);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

繼續理解

我們知道JVM在使用一個類的時候，會先去載入這個類。也就是生成一個Class物件。這個Class物件擁有我們的java程式碼的變數，方法結構。但是它並不是一個例項。因此我們在反射的時候，要先獲取構造方法物件，也就是Class返回給我們的Constructor。此時我們執行這個物件的newInstance，我們就初始化了這個Class，獲取了這個Class的例項。那麼此時我們就可以正常的呼叫方法了。
我們知道，static是屬於類，不需要初始化。那麼此時，反射也側面證實了這個問題。在我們使用static的變數和方法時，set或者invoke的引數傳的是null，因此此時我們使用的是Class物件中的變數和方法。

尾聲

時隔很久都還沒有寫部落格了，是因為自己的確不知道該寫些寫什麼，唉，迷茫，好菜…