android-notes/blogs/Java/反射.md

---
反射
---

#### 目录

1. 思维导图
2. 定义
3. 简单示例
4. Class
   - 如何获取 Class
   - 通过 Class 获取类修饰符和类型
5. Member
   - Field
   - Method
   - Constructor
6. 数组和枚举
7. 反射优缺点
8. 参考

#### 思维导图

![](https://i.loli.net/2019/01/01/5c2ad008a6bdc.png)

#### 定义

1. 对于任意一个类，都能知道这个类的所有属性和方法
2. 对于任意一个对象，都能知道调用它的任意一个属性和方法

这种动态获取信息以及动态调用对象的方法的功能成为 Java 语言的反射机制。

反射机制主要涉及两个类：Class 和 Member。

#### 简单示例

```java
public class UserInfo {
    private String name;
    private int age;

    private UserInfo(String name, int age) {
        this.name = name;
        this.age = age;
//        try {
//            throw new Exception("SingleTon can't ref");
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
```

既然构造方法都私有化了，怎么获取类实例呢？

```java
public class RefDemo {
    public static void main(String[] args) throws Exception {
        Class c = UserInfo.class;
        Constructor constructor = c.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        UserInfo userInfo = (UserInfo) constructor.newInstance("Omooo", 18);
        System.out.println(userInfo.toString());
    }
}

输出：UserInfo{name='Omooo', age=18}
```

#### Class

Class 是反射操作的基础，每个 class 类，无论创建多少个实例对象，在 JVM 中都对应同一个 Class 对象。

##### 如何获取 Class

Java 反射包 java.lang.reflect 中的所有类都没有 public 构造方法，想要获取这些类的实例，只能通过 Class 类获取，所以说如何想使用反射，必须先获取的 Class 对象。

获取 Class 对象有以下几种方法：

1. Object.getClass()

   通过对象实例获取对应的 Class 对象。

   ```java
   Class c = "Omooo".getClass();
   ```

2. The.Class

   ```java
   Class c = String.class;
   ```

3. Class.forName()

   ```java
   Class c = Class.forName("java.lang.String");
   //对于数组比较特殊 String[]：
   Class cStringArray = Class.forName("[[Ljava.lang.String;")	
   ```

4. The.TYPE

   ```java
   Class c = Double.TYPE;
   ```

5. Class.getSuperclass()

##### 通过 Class 获取类修饰符和类型

```java
    public static void main(String[] args) throws Exception {
        Class c = HashMap.class;
        //获取类名 UserInfo
        String className = c.getName();
        System.out.println("类名: " + className);
        //获取类限定符 public
        String modifier = Modifier.toString(c.getModifiers());
        System.out.println("类限定符: " + modifier);
        //获取类泛型参数
        TypeVariable[] typeParameters = c.getTypeParameters();
        if (typeParameters.length > 0) {
            StringBuilder sb = new StringBuilder("泛型参数：");
            for (TypeVariable typeVariable : typeParameters) {
                sb.append(typeVariable.getName());
                sb.append("___");
            }
            System.out.println(sb.toString());
        } else {
            System.out.println("类泛型参数为空！");
        }
        //获取类所实现的接口
        Type[] interfaces = c.getGenericInterfaces();
        if (interfaces.length > 0) {
            StringBuilder sb = new StringBuilder("接口信息：");
            for (Type type : interfaces) {
                sb.append(type.toString());
                sb.append("___");
            }
            System.out.println(sb.toString());
        } else {
            System.out.println("类接口信息为空！");
        }
        //获取继承的父类信息
        List<Class> superClazzs = new ArrayList<>();
        getSuperClassName(c, (ArrayList<Class>) superClazzs);
        if (superClazzs.size() != 0) {
            StringBuilder sb = new StringBuilder("父类信息：");
            for (Class clazz : superClazzs) {
                sb.append(clazz.getName());
                sb.append("___");
            }
            System.out.println(sb.toString());
        }
        //获取类注解信息
        Annotation[] annotations = c.getAnnotations();
        if (annotations.length != 0) {
            StringBuilder sb = new StringBuilder("类注解信息：");
            for (Annotation annotation : annotations) {
                sb.append(annotation.toString());
                sb.append("___");
            }
            System.out.println(sb.toString());
        } else {
            System.out.println("类注解信息为空！");
        }
    }

输出：
类名: java.util.HashMap
类限定符: public
泛型参数：K___V___
接口信息：java.util.Map<K, V>___interface java.lang.Cloneable___interface java.io.Serializable___
父类信息：java.util.AbstractMap___java.lang.Object___
类注解信息为空！
```

#### Member

Member 有三个实现类：

1. Field 对应类变量
2. Method 对应类方法
3. Constructor 对应类构造方法

##### Field

通过 Field 你可以访问给定对象的类变量，包括获取变量的类型、修饰符、注解、变量名、变量值等等，即使变量是 private 的。

- 获取 Field

  Class 提供了四种方法获得给定类的 Field。

  - getDeclaredField(String name)	获取指定的变量，包括 private 的
  - getField(String name) 获取指定的变量，只能是 public 的
  - getDweclaredFields()  获取所有的变量，包括 private 的
  - getFields() 获取所有的变量，只能是 public 的

- 获取变量类型、修饰符、注解

  ```java
      public static void main(String[] args) {
          Class clazz = UserInfo.class;
          Field[] fields = clazz.getDeclaredFields();
          if (fields.length > 0) {
              for (Field field : fields) {
                  StringBuilder sb = new StringBuilder();
                  //变量名
                  String name = field.getName();
                  sb.append("变量名：");
                  sb.append(name);
                  //变量类型
                  String type = field.getType().getName();
                  sb.append("变量类型：");
                  sb.append(type);
                  //变量修饰符
                  String modifer = Modifier.toString(field.getModifiers());
                  sb.append("变量修饰符：");
                  sb.append(modifer);
                  //变量上的注解
                  Annotation[] annotations = field.getDeclaredAnnotations();
                  if (annotations.length > 0) {
                      for (Annotation annotation : annotations) {
                          String annName = annotation.toString();
                          sb.append("注解：");
                          sb.append(annName);
                      }
                  }
                  System.out.println(sb);
              }
          }
      }
  ```

- 获取、设置变量值

  ```java
      public static void main(String[] args) throws Exception {
          UserInfo userInfo = new UserInfo("Omooo", 18);
          System.out.println("Before: " + userInfo.toString());
          Class clazz = userInfo.getClass();
          Field nameField = clazz.getDeclaredField("name");
          nameField.setAccessible(true);
          Field ageField = clazz.getField("age");
          nameField.set(userInfo, "Tom");
          ageField.setInt(userInfo, 19);
          System.out.println("After: " + userInfo.toString());
      }
  ```

  其中，对于 private 的属性、方法或者构造函数，比如要有：

  ```java
  xxx.setAccessible(true);
  ```

  这个方法是 AccessibleObject 中的一个方法，Field、Method、Constructor 都是其子类，该方法的作用就是可以取消 Java 语言访问权限检查。

##### Method

- 获取 Method

  Class 依然提供了四种方法获取 Method：

  ```
  getDeclaredMethod(String name, Class<?>... parameterTypes)
  getMethod(Sting name, Class<?>... parameterTypes)
  getDeclaredMethods()
  getMethods()
  ```

  获取带参数方法时，如果参数类型错误会报 NoSuchMethodException，对于参数是泛型的情况下，泛型必须当成 Object 处理。

- 获取方法返回类型

  ```java
  getReturnType() 获取目标方法返回类型对应的 Class 对象
  getGenericReturnType() 获取目标方法返回类型对应的 Type 对象
  ```

  对于返回值是普通类型如 Object、int、String 等，两者返回值一样。但是有两种特殊情况：

  ```java
  //1.返回值是泛型
  public T function()
  getReturnType() : class java.lang.Object
  getGenericReturnType() : T
  //2.返回值为参数化类型
  public Class<String> function()
  getReturnType(): class java.lang.Class
  getGenericReturnType(): java.lang.Class<java.lang.String>
  ```

- 获取方法参数类型

  ```java
  getParameterTypes()	获取目标方法各参数类型对应的 Class 对象
  getGenericParameterTypes() 获取目标方法各参数类型对应的 Type 对象
  ```

  返回值为数组。

- 获取方法声明抛出的异常的类型

  ```java
  getExceptionTypes() 获取目标方法抛出的异常类型对应的 Class 对象
  getGenericExceptionTypes() 获取目标方法抛出的异常类型对应的 Type 对象
  ```

  返回值为数组。

- 获取方法参数名称

  .class 文件中默认不存储方法参数名称，如果想要获取方法参数名称，需要在编译的时候加上 -parameters 参数。构造方法的参数获取同样。

  ```java
      public static void main(String[] args) throws Exception {
          UserInfo userInfo = new UserInfo("Omooo", 18);
          Class clazz = userInfo.getClass();
          Method nameMethod = clazz.getMethod("setName", String.class);
          Parameter[] parameters = nameMethod.getParameters();
          if (parameters.length > 0) {
              for (Parameter p : parameters) {
                  StringBuilder sb = new StringBuilder();
                  sb.append("参数类型: ");
                  sb.append(p.getType());
                  sb.append("参数名称: ");
                  sb.append(p.getName());
                  System.out.println(sb.toString());
              }
          }
      }
  输出：参数类型: class java.lang.String参数名称: arg0
  ```

  如果编译未加上 -parameters 参数，返回的参数名则形如 ”argX“，X 代表参数的位置。

- 获取方法修饰符

  ```java
  method.getModifiers()
  ```

- 通过反射调用方法

  反射通过 Method 的 invoke() 方法来调用目标方法。第一个参数为需要调用的目标类对象，如果方法是 static 的，则该参数为 null，后面的参数都为目标方法的参数值，顺序与目标方法声明中的参数顺序一致。

  需要注意的是，被调用的方法本身所抛出的异常在反射中都会以 InvocationTargetException 抛出。换句话说，反射调用过程中如果异常 InvocationTargetException 抛出，说明反射调用本身是成功，因为这个异常是目标方法本身所抛出的异常。

##### Constructor

通过反射访问构造方法并通过构造方法构建新的对象。

- 获取构造方法

  和 Method 一样，Class 也提供了四种方法获取：

  ```java
  getDeclaredConstructor(Class<?>... parameterTypes)
  getConstructor(Class<?>... parameterTypes)
  getDeclaredConstructors()
  getConstructors()
  ```

  构造方法的名称、限定符、参数、声明的异常等获取方法和 Method 一致。

- 创建对象

  创建对象有两种方法：

  1. java.lang.reflect.Constructor.newInstance()
  2. Class.newInstance()

  一般来讲，优先使用第一种方法，第二种方法已经被废弃了。它们之间的区别有：

  - 方法一可以调用任意参数的构造方法，而方法二只能调用无参的构造方法
  - 方法一会将原方法抛出的异常都包装成 InvocationTaregtException 抛出，而方法二会将原方法中的异常不做处理原样抛出
  - 方法一不需要方法权限，方法二只能调用 public 的构造方法

  需要注意的是：反射不支持自动装箱，传入参数时要小心。自动装箱是在编译期间的，而反射是在运行期间。

#### 数组和枚举

数组和枚举也是对象，但是在反射中，对数组和枚举的创建、访问和普通对象有点不同，Java 反射为数组和枚举提供了一些特定的 API 接口。

##### 数组

- 数组类型

  数组本质上也是一个对象，所以它也有自己的类型。例如对于 int[] array，数组类型为 class [I。数组类型中的 [ 个数表示数组的维度，其后面的字母代表数组元素类型，即 int，一般为类型的首字母大小。（ long 类型例外，为 J，因为 L 被引用对象类型占用了）

- 创建和初始化数组

  Java 反射为我们提供了 java.lang.reflect.Array 类用来创建和初始化数组。

  ```java
  Array.newInstance(Class<?> componentType, int... dimensions)
  Array.set(Object array, int index, int value)
  Array.get(Object array, int index)
  ```

  例如，用反射创建 int[] array = new int[]{1, 2}：

  ```java
      public static void main(String[] args) throws Exception {
          Object array = Array.newInstance(int.class, 2);
          Array.set(array, 0, 1);
          Array.set(array, 1, 2);
          System.out.println(Array.get(array, 1));
      }
  ```

- 多维数组

  Java 反射没有提供能够直接访问多维数组元素的 API，但你可以把多维数组当成数组的数组处理。

  ```java
      public static void main(String[] args) throws Exception {
          Object matrix = Array.newInstance(int.class, 2, 2);
          Object row1 = Array.get(matrix, 0);
          Object row2 = Array.get(matrix, 1);
          Array.set(row1, 0, 1);
          Array.set(row1, 1, 2);
          Array.set(row2, 0, 3);
          Array.set(row2, 1, 4);
      }
  ```

##### 枚举

枚举隐式继承自 java.lang.Enum，Enum 继承自 Object，所以枚举本质上也是一个类，也可以有成员变量、构造方法、方法等。对于普通类所能使用的反射方法，枚举都能使用，另外，Java 反射额外提供了几个方法。

```java
Class.isEnum()
Class.getEnumConstants()
java.lang.reflect.Field.isEnumConstant()
```

#### 反射优缺点

优点：动态改变类行为

缺点：

1. 性能开销

   反射涉及类型动态解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率低下，尽量避免在高性能要求下使用反射。

2. 安全限制

   使用反射要求程序必须在一个没有安全限制的环境中运行。

3. 内部曝光

   由于反射允许代码执行一些在正常情况下不被允许的操作，所以使用反射可能会导致意料之外的副作用。

#### 参考

[Java 反射完全解析](https://www.jianshu.com/p/607ff4e79a13)