写在前面

今天在需求评审的时候，遇到了挺有意思的要求。需求是什么样子就不说了。总之完成这个需求需要一个调用系统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方法，因为没有参数，所以传nullprintContent.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对象，设置为Dcontent.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面试填坑小分队