写在前面

今天在需求评审的时候，遇到了挺有意思的要求。需求是什么样子就不说了。总之完成这个需求需要一个调用系统api的操作。然而这个api因为并不稳定的原因。被谷歌hide掉了。
这个时候我们最直接的方式就是去通过反射去调用这个系统api。（当然这种方式治标不治本，因为既然被hide，就说明这个api很不稳定。所以这个版本可以用，有可能下个版本就没了）
不过这里我们不考虑这个问题，因为如题所说，这次主角是反射。
之前在用反射的时候，其实并没有去思考反射所带来的东西。而这次在用反射的时候，开始去思考为什么要这么用，它和Java的运行机制有什么关系。
我们在看JVM的时候：多少都能了解到Java的类加载机制，那就是我们在new一个对象的时候，JVM会先使用双亲委派机制去加载这个class文件，class文件的代码结构会被封装成Class对象唯一的出现在方法区中。然后才是我们的实例对象创建到堆中。
之前我去上述的理解没有任何概念，仅仅是当做文字给记了下来。直到我今天在使用反射的时候，突然对上述的概念有了实质性的认识。
不过不着急，让我们一点点的深入....

进入正文

声明一个类

首先我们先声明一个class，内部包含了另一个对象，并且写了一些私有/公有/静态的变量及方法，一会将针对这个class进行反射的操作：

这里的日志使用了Log是Android里的打印输出，而非Java中的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;
    }
}

获取拥有真正对象代码结构的Class：

不知道各位小伙伴们有没有思考过，为什么我们new一个类的时候这么方便，反而到了反射的时候会如此的麻烦？

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();
        }

将Class实例化

        //开始进行具体内部操作，此时我们仅仅是拿到了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);

反射调用变量/static

                /**
                 * 反射调用变量
                 */
                //获取所有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的实例。（这也就是为什么我们反射操作会如此的麻烦）
实例化了这个对象之后，虽然只是一个Object对象，但是它和我们真正new的对象没有任何区别，那么此时我们就可以正常的调用方法了。
我们知道，static是属于类，在类被加载的时候就已经出现了。那么此时，反射也侧面证实了这个问题：
在我们反射调用static的变量和方法时，set或者invoke的参数传的是null，也就是说我们没有传递任何对象实例，所以此时我们使用的是这个在类被加载时就被创建的Class对象中的变量和方法，而非操作的实例对象。因此，对static是不是有了一个更为深刻的理解呢？

尾声

时隔很久都还没有写博客了，是因为自己的确不知道该写些写什么，唉，迷茫，好菜...
希望可以对各位看官有所帮助吧。

我是一个应届生，最近和朋友们维护了一个公众号，内容是我们在从应届生过渡到开发这一路所踩过的坑，已经我们一步步学习的记录，如果感兴趣的朋友可以关注一下，一同加油~

个人公众号：IT面试填坑小分队