运行状态下, 通过反射可以知道任意类的所有属性和方法,。对于任意一个实例对象, 都能调用其任意方法和属性。

1. 反射原理简单剖析:

在讲解反射之前, 我们先了解几个重要的知识点:

1.1 A a = new A() -> 做了什么事情

  1. 类加载器加载A.class文件到内存中, 执行静态代码块和静态方法
  2. 执行new语句, 并在堆中申请一片内存空间.
  3. 调用构造函数, 实例化一个对象. 并逐级调用,初始化属性值。

image.png

疑问: 子类实例化对象, 会不会实例化父类对象??

首先答案肯定是: 子类实例化对象不会实例化对象, 举个简单的例子, 如果我的父类是一个抽象类, 子类继承抽象类。如果子类实例化对象同时也实例化父类对象, 那么就与抽象类不允许实例化有冲突了。只是会调用父类的构造函数对父类属性进行初始化。

1.2 Class文件 & Class类对象:

java文件在编译后会变成class文件, 并会在项目启动的时候由类加载器加载class文件到内存中, JVM根据其字节数创建Class对象.
image.png

Class对象, 描述class文件, class文件中的构造器, 方法可以理解为组件, 对应Class对象的一个个字段。
字段、方法、构造器对象：
image.png
注解数据:
image.png
泛型信息
image.png

例子:

image.png
一个Controller字节码文件, 在加载到内存的时候, 都会被解构保存到Class类中.

1.3 类加载过程 & 类加载器:

详见 https://www.yuque.com/wangyanyang/qz7fwa/xsd243 2.2 和 2.3

2. 反射实际使用:

2.1 获得类对象(三种方式)

java.lang.Class是一个类，这个类是反射操作的源头，即：所有的反射都要从类开始进行，而最关键的是这个类有三种实例化方法, 就是获得类对象。

  1. public static void main(String[] args) {
  2.     /**
  3.          * 方式1: 调用Object类中的getClass()方法
  4.          */
  5.     ReflectTest reflectTest = new ReflectTest();
  6.     Class<? extends ReflectTest> aClass = reflectTest.getClass();
  7.     System.out.println(aClass);
  9.     /**
  10.          * 方式2: 使用“类.class”取得
  11.          */
  12.     Class<ReflectTest> aClass1 = ReflectTest.class;
  13.     System.out.println(aClass1);
  15.     /**
  16.          * 方式3:
  17.          * 调用Class类提供的一个方法--实例化Class对象
  18.          * forName(String className)
  19.          */
  21.     try {
  22.         Class<?> aClass2 = Class.forName("com.interview.javabasic.reflection.ReflectTest");
  23.         System.out.println(aClass2);
  24.     } catch (ClassNotFoundException e) {
  25.         e.printStackTrace();
  26.     }
  27. }

2.2 反射实例化对象

拿到Class类对象, 我们可以使用反射来实例化对象. 如下是反射实例化对象的例子

  1. public class ReflectTest2 {
  2.     private Integer param;
  4.     public static void main(String[] args) {
  5.         ReflectTest2 reflectTest2 = new ReflectTest2();
  6.         reflectTest2.normalMethod();
  7.         reflectTest2.specialMethod();
  8.     }
  10.     public void normalMethod() {
  11.         Book book = new Book();
  12.         System.out.println(book.toString());
  13.     }
  15.     public void specialMethod() {
  16.         Class<Book> bookClass = Book.class;
  17.         try {
  18.             Book book = bookClass.newInstance();
  19.             System.out.println(book.toString());
  20.         } catch (Exception e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24. }
  26. class Book {
  27.     public Book() {
  28.         System.out.println("*** Book的构造方法 ***");
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "--- 这是Book方法 ---";
  34.     }
  35. }

反射在工厂模式中的应用:

  1. public class ReflectTest3 {
  3.     public static void main(String[] args) {
  4.         Fruit apple = Factory.getInstance("com.interview.javabasic.reflection.Apple");
  5.         apple.say("");
  6.         Fruit orange = Factory.getInstance("com.interview.javabasic.reflection.Orange");
  7.         orange.say("");
  8.     }
  9. }
  11. interface Fruit<T> {
  12.     void say(T param);
  13. }
  15. class Apple implements Fruit<String> {
  16.     @Override
  17.     public void say(String param) {
  18.         System.out.println("i am apple");
  19.     }
  20. }
  22. class Orange implements Fruit<String> {
  23.     @Override
  24.     public void say(String param) {
  25.         System.out.println("i am orange");
  26.     }
  27. }
  29. class Factory {
  30.     public static Fruit getInstance(String className) {
  31.         Fruit fruit = null;
  32.         try {
  33.             Class<?> aClass = Class.forName(className);
  34.             fruit = (Fruit) aClass.newInstance();
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.         }
  38.         return fruit;
  39.     }
  40. }

2.3. 反射调用构造方法 & 普通方法 & 成员

  1. public class ReflectTest4 {
  3.     public static void main(String[] args) throws Exception {
  4.         try {
  5.             /**
  6.              * 构造函数部分
  7.              */
  8.             Class<?> aClass = Class.forName("com.interview.javabasic.reflection.Phone");
  9.             Constructor<?>[] constructors = aClass.getConstructors();
  10.             System.out.println("获得公共的构造方法....");
  11.             for (int i = 0; i < constructors.length; i++) {
  12.                 show(constructors[i]);
  13.             }
  14.             System.out.println("获取所有的构造方法...");
  15.             Constructor<?>[] constructors2 = aClass.getDeclaredConstructors();
  16.             for (int i = 0; i < constructors2.length; i++) {
  17.                 show(constructors2[i]);
  18.             }
  19.             System.out.println("获取多参数的, 非公共的构造函数...");
  20.             Constructor<?> constructor = aClass.getDeclaredConstructor(String.class, String.class, String.class);
  21.             System.out.println(constructor);
  22.             System.out.println("获取无参的构造函数...");
  23.             Constructor<?> constructor2 = aClass.getConstructor();
  24.             System.out.println(constructor2);
  25.             /**
  26.              * java.lang.IllegalAccessException: Class com.interview.javabasic.reflection.ReflectTest4 can not access a member of class com.interview.javabasic.reflection.Phone with modifiers "private"
  27.              */
  28.             constructor.setAccessible(true);
  29.             Object iphone = constructor.newInstance("iphone", "9", "699");
  30.             System.out.println("实例化对象:" + iphone);
  31.             System.out.println("-----------------------------------------------");
  33.             /**
  34.              * 获取成员变量
  35.              */
  36.             System.out.println("获取(public)变量...");
  37.             Field[] fields = aClass.getFields();
  38.             for (int i = 0; i < fields.length; i++) {
  39.                 show(fields[i]);
  40.             }
  41.             System.out.println("获取所有的变量...");
  42.             Field[] allFields = aClass.getDeclaredFields();
  43.             for (int i = 0; i < allFields.length; i++) {
  44.                 show(allFields[i]);
  45.             }
  46.             System.out.println("获取某一个public变量...");
  47.             Field price = aClass.getDeclaredField("price");
  48.             price.set(iphone, "6999");
  49.             System.out.println("实例化对象:" + iphone);
  51.             System.out.println("获取某一个private变量...");
  52.             Field size = aClass.getDeclaredField("size");
  53.             size.setAccessible(true);
  54.             size.set(iphone, "15.6");
  55.             System.out.println("实例化对象:" + iphone);
  57.             System.out.println("-----------------------------------------------");
  58.             /**
  59.              * 获取成员方法
  60.              */
  61.             System.out.println("获取(public)方法...");
  62.             Method[] methods = aClass.getMethods();
  63.             for (int i = 0; i < methods.length; i++) {
  64.                 show(methods[i]);
  65.             }
  66.             System.out.println("获取所有的方法...");
  67.             Method[] allMethods = aClass.getDeclaredMethods();
  68.             for (int i = 0; i < allMethods.length; i++) {
  69.                 show(allMethods[i]);
  70.             }
  71.             System.out.println("获取某一个public方法...");
  72.             Method price2 = aClass.getDeclaredMethod("setPrice", String.class);
  73.             price2.invoke(iphone, "9999");
  74.             System.out.println("实例化对象:" + iphone);
  76.             System.out.println("获取某一个private方法...");
  77.             Method show = aClass.getDeclaredMethod("show");
  78.             show.setAccessible(true);
  79.             show.invoke(iphone);
  80.         } catch (Exception e) {
  81.             e.printStackTrace();
  82.         }
  83.     }
  85.     private static <T> void show(T param) {
  86.         System.out.println(param);
  87.     }
  88. }
  90. class Phone {
  91.     String name;
  92.     private String size;
  93.     public String price;
  96.     private Phone(String name, String size, String price) {
  97.         this.name = name;
  98.         this.size = size;
  99.         this.price = price;
  100.     }
  102.     public Phone() {
  103.     }
  105.     @Override
  106.     public String toString() {
  107.         return "--- 这是Phone方法 ---" + this.name + "," + this.size + "," + this.price;
  108.     }
  110.     public void setPrice(String price) {
  111.         this.price = price;
  112.     }
  114.     private void show() {
  115.         System.out.println("Phone's size:" + size + ", only " + price + " RMB");
  116.     }
  117. }