目录
一、什么是反射
二、反射的作用和应用场景
三、反射的优缺点
四、使用反射（获取Class对象、获取类的构造方法及其参数类型和修饰类型、通过构造函数的newInstance方法创建类的实例、获取类的方法并调用它、获取和修改类的属性 等等）
五、反射问题探索
一、什么是反射
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。
二、反射的作用和应用场景
作用
- 获取任意类的名称、package 信息、所有属性、方法、注解、类型、类加载器、modifiers、父类、现实接口等
- 获取任意对象的属性，并且能改变对象的属性
- 调用任意对象的方法
- 判断任意一个对象所属的类
- 实例化任意一个类的对象
- 生成动态代理。
应用场景
1.实例化系统隐藏的类
2.调用对象被隐藏起来的属性和方法
3.动态代理
4.与注解的结合使用
5.在编译时无法知道该对象或类可能属于哪些类，程序在运行时获取对象和类的信息
反射的作用和应用场景有点类似了，我们只要记住反射的作用，就能在你遇到问题的时候想起它。反射一般是用来开发框架，在我们平常的开发中，反射用得并不多，但是我们必须搞懂它，它可以帮助我们理解一些框架的原理，有一句很经典的话就是：反射是框架设计的灵魂
三、反射的优缺点
优点
提高了 Java 程序的灵活性和扩展性，降低耦合性，提高自适应能力。
允许程序创建和控制任何类的对象，无需提前硬编码目标类
应用很广，测试工具、框架都用到了反射
缺点
性能问题：反射是一种解释操作，远慢于直接代码。因此反射机制主要用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用
模糊程序内部逻辑：反射绕过了源代码，无法再源代码中看到程序的逻辑，会带来维护问题
增大了复杂性：反射代码比同等功能的直接代码更复杂
四、使用反射
1、获取Class类对象，三种方式
//通过Class.forName()方法获取
try {
Class test = Class.forName("com.mumumxi.test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//通过对象的getClass()方法获取
String string = "test";
Class test1 = string.getClass();
//直接通过类字面常量获取
Class test2 = String.class;
2、获取类的构造方法及其参数类型和修饰语
package com.mumuxi.testapplication;
import java.lang.reflect.Constructor;
/**
* @author mumuxi
* @date 2020/1/19
*/
public class Test {
public static final String TAG = Test.class.getSimpleName();
public Test() {
}
public Test(int i) {
}
public Test(int i, String string) {
}
public static void main(String[] args) {
Class test = null;
try {
test = Class.forName("com.mumuxi.testapplication.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//getDeclaredConstructors 返回类的所有构造函数，包括私有的
Constructor[] constructors = test.getDeclaredConstructors();
for (Constructor constructor : constructors) {
//通过getParameterTypes 获取构造函数的参数Class列表
for (Class name : constructor.getParameterTypes()) {
System.out.println(name.getName());
}
//通过getModifiers获取构造函数的修饰类型，是private的还是public..
System.out.println(constructor.getModifiers());
System.out.println("--------------------------------");
}
//getConstructors 返回public类型的构造函数
Constructor[] constructors1 = test.getConstructors();
//获取无参的构造函数
try {
Constructor constructor = test.getDeclaredConstructor();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
//获取只有一个参数的构造函数，参数类型是int
Class[] classes = {int.class};
try {
Constructor constructor1 = test.getDeclaredConstructor(classes);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
//获取只有两个参数的构造函数,参数类型依次是int 、String
Class[] classes1 = {int.class, String.class};
try {
Constructor constructor1 = test.getDeclaredConstructor(classes1);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
3、通过构造函数的newInstance方法创建类的实例
package com.mumuxi.testapplication;
import android.util.Log;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author mumuxi
* @date 2020/1/19
*/
public class Test {
public static final String TAG = Test.class.getSimpleName();
public Test() {
}
public Test(int i) {
}
public Test(int i, String string) {
}
public static void main(String[] args) {
Class test = null;
try {
test = Class.forName("com.mumuxi.testapplication.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor constructor = null;
//调用无参构造函数新建类的实例
if (test != null) {
try {
constructor = test.getDeclaredConstructor();
constructor.setAccessible(true);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
if (constructor != null) {
try {
Object object = constructor.newInstance();
if (object instanceof Test) {
System.out.println("create object success");
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
//调用含有一个参数的构造函数新建类的实例
Class[] param = {int.class};
if (test != null) {
try {
constructor = test.getDeclaredConstructor(param);
constructor.setAccessible(true);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
if (constructor != null) {
try {
Object object = constructor.newInstance(1);
if (object instanceof Test) {
System.out.println("create object success");
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
//调用含有两个参数的构造函数新建类的实例
Class[] param1 = {int.class, String.class};
if (test != null) {
try {
constructor = test.getDeclaredConstructor(param1);
constructor.setAccessible(true);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
if (constructor != null) {
try {
Object object = constructor.newInstance(1, "hehe");
if (object instanceof Test) {
System.out.println("create object success");
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
4、获取类的方法并调用它（私有、公共、静态）
package com.mumuxi.testapplication;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author mumuxi
* @date 2020/1/19
*/
public class Test {
private static final String TAG = Test.class.getSimpleName();
public static void main(String[] args) {
Test test = new Test();
Method method = null;
//获取一个对象的私有或公共方法并调用它
try {
/*通过Class对象的getDeclaredMethod方法获取指定方法，
第一个参数是方法名，第二个参数是方法的参数Class对象列表*/
method = Test.class.getDeclaredMethod("test", null);
//method 是私有类型的还需要通过setAccessible给予权限
method.setAccessible(true);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (method != null) {
try {
//通过invoke来执行该方法第,一个参数是类实例，第二个是方法的参数列表
method.invoke(test, null);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
//获取指定类的私有方法并调用它
try {
method = Test.class.getDeclaredMethod("test1");
//method 是私有类型的还需要通过setAccessible给予权限
method.setAccessible(true);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (method != null) {
try {
//通过invoke来执行该方法第,一个参数是类实例，第二个是方法的参数列表
method.invoke(null);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
private void test() {
System.out.println("hehe");
}
public static void test1(){
System.out.println("hehe1");
}
}
5、获取和修改类的属性 （私有、公共、静态）
package com.mumuxi.testapplication;
import java.lang.reflect.Field;
/**
* @author mumuxi
* @date 2020/1/19
*/
public class Test {
public static final String TAG = Test.class.getSimpleName();
private String test = "test";
private static String TEST = "TEST";
public static void main(String[] args) {
Class test = null;
try {
test = Class.forName("com.mumuxi.testapplication.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获取实例的指定字段并修改它的值
Object object = null;
if (test != null) {
try {
object = test.newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
Field field = null;
if (test != null) {
try {
//通过Class对象的getDeclaredField获取指定属性，参数是属性名
field = test.getDeclaredField("test");
field.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
if (field != null && object != null) {
try {
//通过Field的get方法获取指定实例的字段，参数是具体的实例
Object fieldObject = field.get(object);
System.out.println("非静态字段------------");
if (fieldObject instanceof String) {
System.out.println("String 类型");
}
System.out.println(fieldObject);
/*通过Field的set方法修改指定实例的字段
第一个参数是具体的实例，第二个参数是需要修改的值*/
field.set(object, "改掉了");
System.out.println(field.get(object));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
//修改类的静态字段
if (test != null) {
try {
//通过Class对象的getDeclaredField获取指定属性，参数是属性名
field = test.getDeclaredField("TEST");
field.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
try {
System.out.println("静态字段------------");
Object staticObject = field.get(null);
System.out.println(staticObject);
field.set(staticObject, "ABCD");
System.out.println(field.get(null));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
6、通过Class对象getSuperclass方法的获取类的父类
Class test = null;
try {
test = Class.forName("com.mumuxi.testapplication.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if (test != null) {
Class superClass = test.getSuperclass();
}
7、获取类的接口
Class test = null;
try {
test = Class.forName("com.mumuxi.testapplication.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if (test != null) {
Class[] interfaces = test.getInterfaces();
}
推荐使用 Joor反射库 ，可以参考Java反射库jOOR简介
五、反射问题探索
1.Java中的final字段真的不能修改么？(怎样修改final字段)
通过反射是可以修改final字段的！但是一般情况下不建议这么做，如果出现问题也比较难排查。
具体可以参考：https://blog.csdn.net/adu003/article/details/104376399
2.反射可以破坏单例吗？
反射可以破坏单例，但是我们也可以通过一些方法防御被反射破坏单例。
3.反射的优缺点
优点：
1.能够运行时动态地获取类的实例，提高灵活性
2.与动态编译结合
缺点：
1）使用反射性能较低，需要解析字节码，将内存中的对象进行解析。
解决方案：
1、通过setAccessible(true)关闭JDK的安全检查来提升反射速度；
2、多次创建一个类的实例时，有缓存会快很多
3、ReflflectASM工具类，通过字节码生成的方式加快反射速度
2）相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）
