我第一次看到反射的时候觉得很难理解，可能没有这样操作过。后来在慢慢写代码的过程中理解了这种做法。

反射的概念以及机制

反射机制是什么？是通过字节码文件找到其中的一个类，然后也可以找到类中的相关属性等。
我们正常一般的思维是编写java代码，然后代码会被编译为字节码文件。而我们的方法都是
自己在代码中写的，现在这个机制可以通过字节码找到代码中的属性。这就是反射机制的特
点。

获取字节码文件对象的三种方式

1：通过getClass() 方法获取到Class对象。

这个方法是在Object类中的一个方法，去api查找详细的说明。
image.png
这个方法的返回类型是Object的运行时类，Object是所有类的父类。所以我们可以认为是返回一个类的对象。这个方法需要我们用实例化的对象去调用。这是基本的常识，所以我们任何情况下，想要用这个方法获取到字节码文件对象，就需要Object类的实例化对象或者继承自Object类的实例化对象。

2：通过类名.class获取到Class对象

似乎这种是一种更加简单的方式。

  1.   Class<Refelct_demo01> re_1 = Refelct_demo01.class;

3：通过Class.forName()获取到Class对象

根据api的说明举例就很容易明白了。

image.png
Class 提供了两个这样的重载方法。

image.png
注意返回是一个static修饰的类对象。
简单举例一下使用

  1.  Class<?> aClass = Class.forName("java_practice.Student");

三种获取Class 对象的区别（该段在语雀的公开文档引用）

  • getClass() 接在对象的后面。getClass() 是 Object 类中的方法，而 Object 类是所有 Java 类的父类。
  • .class 接在任意一个 Class 类的后面，在编译期加载（静态加载）。
  • Class.forName 是 Class 类中的一个静态方法，从指定的 classloader 中装载类，返回与给定字符串对应类或接口的 Class 对象，在运行期加载（动态加载）。

    关于静态加载和动态加载：

    1. 静态加载的类的源程序在编译时期加载（必须存在），而动态加载的类在编译时期可以缺席（源程序不存在时编译器也不会报错）。
  1. 当类找不到的时候，静态加载方式会抛出异常”NoClassDefFoundError”，而动态加载方式则抛出”ClassNotFoundException”异常。

Class.forName() 和 ClassLoader 的 loadClass() 之间的区别：

  • Class.forName() 加载类是将类进了初始化，而 ClassLoader 的 loadClass() 方法并没有对类进行初始化，只是把类加载到了虚拟机中。
  • Spring 框架中 IOC 容器的实现就是使用的 ClassLoader 的 loadClass() 方法。
  • 而在我们使用 JDBC 时通常是使用 Class.forName() 方法来加载数据库连接驱动。这是因为在 JDBC 规范中明确要求 Driver (数据库驱动)类必须向 DriverManager 注册自己。

实例化

我们要通过反射的方式进行实例化

现在想想，如果不用反射的话，我们怎么样实例化对象？通过new进行实例化。

  1.  Refelct_demo01 re = new Refelct_demo01();

但是反射是什么？我们先通过Class对象获得构造器。为什么要这样做？你可以理解为它是倒着来的。
我们正常的是有i了构造器，然后实例化。现在我们这样去做。

构造器的获取在Class类中一个给了两个，一个是指定构造器，一个是返回一个数组。我们来看。

image.png

注意这两个只能拿到public修饰的构造器，要想拿到全部。我们可以用

image.png

举例子
指定构造器

  1.  Class<?> aClass = Class.forName("java_practice.Student");
  2.         //基本数据类型也可以通过.class 得到对应的Class 类型
  3.  Constructor<?> con = aClass.getConstructor(int.class, String.class); //填入指定构造方法中的类型.class即可
  4.  System.out.println(con);//public java_practice.Student(int,java.lang.String)
  5. //可获取到私有构造方法
  6.  Constructor<?> dd = aClass.getDeclaredConstructor(String.class);
  7.  System.out.println(dd);//private java_practice.Student(java.lang.String)

获取构造器数组对象

  1.   Class<?> aClass = Class.forName("java_practice.Student");
  2.   Constructor<?>[] cons = aClass.getConstructors();//拿到public类型的构造方法
  3.   for(Constructor con : cons)
  4.         {
  5.             System.out.println(con);
  6.         }
  7.   Constructor<?>[] dc = aClass.getDeclaredConstructors();//拿到所有的构造方法
  8.   for(Constructor dcc: dc)
  9.         {
  10.             System.out.println( dcc);
  11.         }

在获取到构造器之后呢，我们可以利用得到的构造器对象创建实例对象。

举个·例子，通过无参构造器来创建一个实例对象/类对象

获取一般方法和成员变量

同样可以获取到方法和成员变量

获取一般方法（成员方法）

首先，我们还是可以先获取到Class对象，然后获取成员方法

api提供了两个获取一般方法的方法

image.png

同样一个是返回指定的方法对象，一个是返回一个数组

  1. //获取单个方法公共的方法对象
  2. Method m = aClass.getMethod("getName");
  4. //获取到成员方法对象(包括了继承的方法)
  5. Method[] methods = aClass.getMethods();
  6. for(Method method:methods)
  7.       {
  8.          System.out.println(method);
  9.       }

但是这样获取的一般只是公共的方法，私有化的方法是获取不到的。Class 类也提供了获取所有的方法包括私有方法的方法。

image.png

  1. Method speak__ = aClass.getDeclaredMethod("speak__");//static 修饰的方法
  2. Method kk = aClass.getDeclaredMethod("kk");//kk是私有化方法
  3. Method[] mm = aClass.getDeclaredMethods();
  4. for(Method m : mm)
  5.     {
  6.        System.out.println(m );
  7.     }

获取到成员变量

与此相关的Class提供的方法

image.png
image.png

  1. Field field = aClass.getField("say");//public类型的
  2. Field[] fields = aClass.getFields();
  3. for(Field f : fields)
  4.      {
  5.          System.out.println(f);
  6.      }
  7.  Field name = aClass.getDeclaredField("name");//name是私有的
  9.  Field[] ff = aClass.getDeclaredFields();
  10.  for(Field f : ff)
  11.       {
  12.          System.out.println(f);
  13.       }

使用类属性

我们已经了解到如何获取到Class对象，构造器，方法，局部变量。那么我们如果去调用一个方法或者如何去给一个类的成员变量赋值？

实现方法的调用

正常情况下，如果不是用到反射进行编程的话，我们可以用实例对象去调用一个方法。现在我们也实现实例方法对方法的人调用，只不过方式是不一样的。感受一下。

  1.         Class<?> aClass = Class.forName("java_practice.Student");//获取到Class 对象
  2.         Constructor<?> con = aClass.getConstructor();//获取获取构造器
  3.         Object o = con.newInstance();//获取实例化对象
  4.         Method m = aClass.getMethod("speak");//获取指定的方法对象
  5.         m.invoke(o);//调用实例化对象下的指定方法

注意对私有方法的调用的时候，还需要进行跳过访问检查，才可以调用到。具体参考。

  1.         Constructor<?> con = aClass.getConstructor();//获取获取构造器
  2.         Object o = con.newInstance();//获取实例化对象
  3.         Method kk = aClass.getDeclaredMethod("kk");//kk是私有化的
  4.         kk.setAccessible(true);//跳过访问检查
  5.         kk.invoke(o);

给成员变量赋值

  1.         Field field = aClass.getField("say");
  2.         //获取无参构造方法创建对象
  3.         Constructor<?> con = aClass.getConstructor();
  4.         Object obj = con.newInstance();
  5.         field.set(obj,"hello");//给obj的成员变量say 赋值
  1.         Field field = aClass.getField("say");//获取成员变量对象
  2.         Constructor<?> con = aClass.getConstructor();//获取构造器
  3.         Object obj = con.newInstance();//获取类实例对象
  4.         field.set(obj,"hello");//给obj的成员变量say 赋值
  5.         Object o = field.get(obj);//获取obj对象下的成员say的对象
  6.         System.out.println(o);//获取到成员变量的值

私有化的成员变量的一样要越过访问检查

  1.         Field name = aClass.getDeclaredField("name");
  2.         Constructor<?> con_ = aClass.getConstructor();
  3.         Object o1 = con_.newInstance();
  4.         name.setAccessible(true);
  5.         name.set(o1,"jgdabc");
  6.         Object o = name.get(o1);
  7.         System.out.println(o);

反射越过泛型检查

这样的特点如何体现？

如果我定义一个集合，集合中的泛型是Integer的，我现在要给这个集合存放一个String类型的数据。
可以吗？用2反射的这个机制就可以实现。

  1. package reflect_demo;
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  5. import java.util.ArrayList;
  7. //实现ArrayList<Integer>集合，给利用反射的特点给集合当中添加字符串数据
  8. public class ReflectDemo08 {
  9.     public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
  10.         ArrayList<Integer> array = new ArrayList<Integer>();
  11.         array.add(1);
  12. //        通过反射实现正常情况下，无法实现的操作
  13.         Class<? extends ArrayList> arr_cla = array.getClass();//还是获取到Class对象
  14.         Method m = arr_cla.getMethod("add", Object.class);//调用到add方法,可以知道这个是Object类型的方法
  15.          m.invoke(array, "hello"); //给array对象下的m里面的add方法传入值
  16.          //反射可以越过泛型检查的，获取到原始的参数所需要的参数类型
  17.         System.out.println(array);
  20.     }
  21. }

image.png
有没有觉得很有逼数。

反射运行配置文件指定内容

创建两个类

  1. package reflect_demo;
  3. public class Teacher666 {
  4.     public void teach()
  5.     {
  6.         System.out.println("love students");
  7.     }
  8. }
  1. package reflect_demo;
  3. public class Student666 {
  4.     public void study()
  5.     {
  6.         System.out.println("study hard");
  9.     }
  10. }

给一个简单的配置文件Class.txt

  1. className = reflect_demo.Student666
  2. methodName = study

然后测试类·

  1. package reflect_demo;
  2. //通过配置文件运行类中的方法
  4. import java.io.FileNotFoundException;
  5. import java.io.FileReader;
  6. import java.io.IOException;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.lang.reflect.Method;
  10. import java.util.Properties;
  12. public class ReflectDemo09 {
  13.     public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
  14.         //加载数据
  15.         Properties prop = new Properties();
  16.         FileReader fileReader = new FileReader("E:\\java_doc\\src\\reflect_demo\\class.txt");
  17.         prop.load(fileReader);
  18.         fileReader.close();
  19.         String className = prop.getProperty("className");//相当于根据键获取到值。
  20.         String methodName = prop.getProperty("methodName");
  21.         //通过反射来使用
  22.         Class<?> c = Class.forName(className);
  23.         Constructor<?> con = c.getConstructor();
  24.         Object o = con.newInstance();
  25.         Method m = c.getMethod(methodName);
  26.         m.invoke(o);
  30.     }
  31. }

这样做的好处是，在我想要在该类指定运行对象的时候，我不需要在该类中进行指定类，或者像之前一样进行new对象，我想要运行对象的哪个方法，就直接在配置文件中进行简单修改就可以了。这里就体现了反射的这方面的特点。简单演示一下。反射是非常重要的一个知识点。在Spring中就会有用到反射的知识点，所以感觉基础扎实点会比较好，如果不是理解的就去用的话，很容易陷入迷茫，并且效率很低。

反射的有点，我们上面的简单说明体现了一部分。缺点在于动态解析这些方面，以及安全等等。其实你从代码上可以看的出来，从字节码进行找到这个类，然后获取相关的属性等等，这样其实是比较麻烦的，浪费效率，另外代码是无法和常规编程一样进行优化。反射可以做到一些我们常规方式下五发进行的操作，所以会存在安全的隐患。这样的实现很明显会破坏掉类的封装性等等。

但是我们会用到它，在工厂模式下会有非常大的用处。感觉有趣。