You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
android-notes/blogs/Java/反射.md

15 KiB

反射

目录

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

思维导图

定义

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

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

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

简单示例

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 +
                '}';
    }
}

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

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 对象。

    Class c = "Omooo".getClass();
    
  2. The.Class

    Class c = String.class;
    
  3. Class.forName()

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

    Class c = Double.TYPE;
    
  5. Class.getSuperclass()

通过 Class 获取类修饰符和类型
    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 的
  • 获取变量类型、修饰符、注解

        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);
                }
            }
        }
    
  • 获取、设置变量值

        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 的属性、方法或者构造函数,比如要有:

    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 处理。

  • 获取方法返回类型

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

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

    //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>
    
  • 获取方法参数类型

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

    返回值为数组。

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

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

    返回值为数组。

  • 获取方法参数名称

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

        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 代表参数的位置。

  • 获取方法修饰符

    method.getModifiers()
    
  • 通过反射调用方法

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

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

Constructor

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

  • 获取构造方法

    和 Method 一样,Class 也提供了四种方法获取:

    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 类用来创建和初始化数组。

    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}:

        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,但你可以把多维数组当成数组的数组处理。

        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 反射额外提供了几个方法。

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

反射优缺点

优点:动态改变类行为

缺点:

  1. 性能开销

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

  2. 安全限制

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

  3. 内部曝光

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

参考

Java 反射完全解析