【Hello】反射

发表于 | 分类于 | 阅读次数：

介绍
Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。

反射

Class 类

类是对象，类是 java.lang.Class 类的实例对象，这个对象也称为类的类型。

实例对象的类类型的三种表达方式：

  1. 类名.class
  2. 实例对象.getClass()
  3. Class.forName("类的全称") // 类的全称：包名 + 类名

Code

  • Target.java
1
2
3
4
5
6
7
8
9
10
11
@Setter
@Getter
public class Target {

    private String name;
    private int age;

    public Target() {
        this.name = "LeifChen";
    }
}
  • ReflectDemo.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ReflectDemo {

    public static void main(String[] args) {
        Target target = new Target();

        // 1.任何一个类都有一个隐含的静态成员变量 class
        Class c1 = Target.class;

        // 2.通过实例对象的 getClass() 方法
        Class c2 = target.getClass();

        // 3.通过 Class.forName ("类名字符串")
        Class c3 = null;
        try {
            c3 = Class.forName("com.chen.reflect.Target");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println(c1 == c2);
        System.out.println(c2 == c3);

        try {
            // 需要无参数的构造方法
            Target target2 = (Target) c1.newInstance();
            System.out.println(target2.getName());
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

动态加载类

  • 1.静态加载类：编译时刻加载类
  • 2.动态加载类：运行时刻加载类

new 创建对象，是静态加载类。

通过反射获取类的信息

  1. 获取构造函数 java.lang.reflect.Constructor<T>
  2. 获取方法 java.lang.reflect.Method
  3. 获取成员变量 java.lang.reflect.Field

Code

  • ReflectUtil.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * ReflectUtil
 *
 * @Author LeifChen
 * @Date 2018-09-28
 */
public class ReflectUtil {

    /**
     * 打印类的构造函数
     *
     * @param obj
     */
    public static void printConstrutorMethods(Object obj) {
        System.out.println("类的构造函数：");

        Class c = obj.getClass();
        Constructor[] constructors = c.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            // 构造函数的名称
            System.out.print(constructor.getName() + "(");
            // 构造函数的参数类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++) {
                System.out.print(paramTypes[i].getSimpleName());
                if (i < paramTypes.length - 1) {
                    System.out.print(",");
                }
            }
            System.out.println(")");
        }
    }

    /**
     * 打印类的方法
     *
     * @param obj
     */
    public static void printMethods(Object obj) {
        System.out.println("类的方法：");

        Class c = obj.getClass();
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            // 方法的返回值类型的类类型
            Class rtnType = method.getReturnType();
            System.out.print(rtnType.getSimpleName() + " ");
            // 方法名称
            System.out.print(method.getName() + "(");
            // 方法的参数类型
            Class[] paramTypes = method.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++) {
                System.out.print(paramTypes[i].getSimpleName());
                if (i < paramTypes.length - 1) {
                    System.out.print(",");
                }
            }
            System.out.println(")");
        }
    }

    /**
     * 打印类的成员变量
     *
     * @param obj
     */
    public static void printFields(Object obj) {
        System.out.println("类的成员变量：");

        Class c = obj.getClass();
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            // 成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getSimpleName();
            // 成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName + " " + fieldName);
        }
    }
}
  • 测试方法 Main.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {

    public static void main(String[] args) {
        String s = "hello";
        System.out.println("类的全称是：" + s.getClass().getName());
        ReflectUtil.printConstrutorMethods(s);
        ReflectUtil.printMethods(s);
        ReflectUtil.printFields(s);

        System.out.println("=====================================");

        int i = 100;
        System.out.println("类的全称是：" + Integer.class.getName());
        ReflectUtil.printConstrutorMethods(i);
        ReflectUtil.printMethods(i);
        ReflectUtil.printFields(i);
    }
}

方法反射

方法的名称和方法的参数列表才能唯一决定某个方法。
Method method = c.getDeclaredMethod("方法名"，可变参数列表（参数类型.class）)
method.invoke(对象，参数列表)

Code

  • ReflectDemo2.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * ReflectDemo2
 *
 * @Author LeifChen
 * @Date 2018-09-28
 */
public class ReflectDemo2 {

    public static void main(String[] args) {
        MyClass my = new MyClass();
        Class c = my.getClass();
        try {
            Method method1 = c.getMethod("print");
            method1.invoke(my);

            System.out.println("=====");
            Method method2 = c.getMethod("print", int.class, int.class);
            method2.invoke(my, 10, 20);

            System.out.println("=====");
            Method method3 = c.getMethod("print", String.class, String.class);
            method3.invoke(my, "hello", "reflect");
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    public void print() {
        System.out.println("Print");
    }

    public void print(int a, int b) {
        System.out.println(a + b);
    }

    public void print(String a, String b) {
        System.out.println(a.toUpperCase() + " " + b.toUpperCase());
    }
}

集合的泛型

集合在编译期会检查泛型，而编译后的集合是去泛型化的。因此，可以通过反射，绕过编辑器的泛型检查，从而了解集合的泛型本质。

Code

  • ReflectDemo3.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * ReflectDemo3
 *
 * @Author LeifChen
 * @Date 2018-09-28
 */
public class ReflectDemo3 {

    public static void main(String[] args) {
        List list1 = new ArrayList();
        List<String> list2 = new ArrayList<>();
        list2.add("hello");
        // 编译期检查错误
        /* list2.add(100); */

        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        // true：说明编译之后集合的泛型是去泛型化的
        System.out.println(c1 == c2);

        // 使用反射可以绕过编译期的泛型检查
        try {
            Method method = c2.getMethod("add", Object.class);
            method.invoke(list2, 100);
            System.out.println(list2);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
0%