反射

反射是Java中一种用于动态获取类或对象的信息以及动态调用对象方法的功能机制。在运行状态中，对于任意一个类，使用反射可以获取这个类的所有属性和方法；对于任意一个对象，使用反射能够调用它的任意属性和方法。利用反射可以无视对象的修饰符，调用类里面的内容。利用反射可以跟配置文件结合起来使用，把要创建的对象信息和方法写在配置文件中。

使用反射包含以下步骤：

获取class字节码文件对象。
利用反射可以操作类或对象的信息有：
- 构造方法（获取、创建对象）
- 成员变量（获取、赋值）
- 成员方法（获取、运行）

获取字节码文件对象

Java中的每个类都是一个Class对象（字节码文件对象）。获取字节码文件对象共有以下三种方式：

通过class字节码文件获取：Class.forName("类的全类名")

类的全类名=类的包名.类名。

使用该方式，是通过.java源代码文件编译后生成的.class字节码文件获取。
```
1Class clazz = Class.forName("com.linner.repo.Student");
```
通过Class对象的class属性获取：类名.class

该方式是对象已载入内存后使用的，需要使用import语句将对应的类导入（.class文件加载到内存后产生的Class对象也是唯一的）。
```
1Class clazz = Student.class;
```
通过对象获取：对象.getClass()

通过创建对象后的getClass()方法来返回该对象的Class对象。该方法需要创建具体对象后才能使用。
```
1Student student = new Student();
2Class clazz = student.getClass();
```

以上三种方法获取到的Class对象均为同一个对象。即，使用==分别判断以上三种方法获取到的对象均为true。

获取了Class对象后就可以获取到该类的各种信息。

获取构造方法

获取构造方法即为获取Constructor对象。

方法名	说明
`Constructor<?>[] getConstructors()`	获得所有的公共构造方法（`public`）
`Constructor<?>[] getDeclaredConstructors()`	获得所有的构造方法（包括`private`）
`Constructor<T> getConstructor(Class<?>... parameterTypes)`	获取指定的公共构造方法
`Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)`	获取指定的构造方法（包括`private`）

Example：

 1public class Student {
 2    public Student() {
 3        System.out.println("创建了一个Student对象");
 4    }
 5
 6    private Student(String name) {
 7        System.out.println("创建了一个Student对象：" + name);
 8    }
 9
10    public Student(String name, int age) {
11        System.out.println("创建了一个Student对象：name=" + name + ", age=" + age);
12    }
13}

 1public class ReflectDemo {
 2    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
 3        // 获取Class对象
 4        Class clazz = Class.forName("com.linner.repo.Student");
 5
 6        // 获取所有公共构造方法对象
 7        Constructor[] constructors1 = clazz.getConstructors();
 8        for (Constructor constructor : constructors1) {
 9            System.out.println(constructor);
10        }
11
12        System.out.println("=======================");
13
14        // 获取所有构造方法对象（包括private）
15        Constructor[] constructors2 = clazz.getDeclaredConstructors();
16        for (Constructor constructor : constructors2) {
17            System.out.println(constructor);
18        }
19
20        System.out.println("=======================");
21
22        // 获取指定的构造方法对象
23        // 空参构造方法
24        Constructor con1 = clazz.getConstructor();
25        System.out.println(con1);
26        // 包含参数的构造方法
27        Constructor con2 = clazz.getConstructor(String.class, int.class);
28        System.out.println(con2);
29        // 获取指定的构造方法对象（包括private）
30        Constructor con3 = clazz.getDeclaredConstructor(String.class);
31        System.out.println(con3);
32    }
33}

通过反射创建对象

使用Constructor对象的newInstance()方法可以为反射的类创建对象。

Example：

 1public class ReflectDemo {
 2    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
 3        // 获取Class对象
 4        Class clazz = Class.forName("com.linner.reflect.Student");
 5
 6        // 获取无参的公共构造方法
 7        Constructor con1 = clazz.getConstructor();
 8        // 使用无参的构造方法创建对象
 9        Student stu1 = (Student) con1.newInstance();
10        System.out.println(stu1);
11
12        // 获取带参数的构造方法（包括private）
13        Constructor con2 = clazz.getDeclaredConstructor(String.class, int.class);
14        // 暴力反射
15        // 如果是private修饰的构造方法，需要临时修改构造方法的访问权限（取消检查访问权限）
16        con2.setAccessible(true);
17        // 使用带参数的构造方法创建对象
18        Student stu2 = (Student) con2.newInstance("zhangsan", 23);
19        System.out.println(stu2);
20    }
21}

获取成员变量

获取成员变量即为获取Field对象。

方法名	说明
`Field[] getFields()`	返回所有公共成员变量对象（`public`）
`Field[] getDeclaredFields()`	返回所有成员变量对象（包括`private`）
`Field getField(String name)`	返回指定名称的公共成员变量对象（`public`）
`Field getDeclaredField(String name)`	返回指定名称的成员变量对象（包括`private`）

Example：

1public class Student {
2    public String name;
3    private int age;
4    public String gender;
5    private String address;
6}

 1public class ReflectDemo {
 2    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
 3        // 获取Class对象
 4        Class clazz = Class.forName("com.linner.reflect.Student");
 5
 6        // 获取所有公共成员变量对象
 7        Field[] fields1 = clazz.getFields();
 8        for (Field field : fields1) {
 9            System.out.println(field);
10        }
11
12        System.out.println("====================");
13
14        // 获取所有成员变量（包括private）
15        Field[] fields2 = clazz.getDeclaredFields();
16        for (Field field : fields2) {
17            System.out.println(field);
18        }
19
20        System.out.println("====================");
21
22        // 获取指定名称的公共成员变量
23        Field nameField = clazz.getField("name");
24        System.out.println(nameField);
25
26        System.out.println("====================");
27
28        // 获取指定名称的成员变量（包括private）
29        Field ageField = clazz.getDeclaredField("age");
30        System.out.println(ageField);
31    }
32}

利用反射获取和修改成员变量的值

可以使用以下Field对象方法对成员变量的值进行修改：

赋值：
```
1void set(Object obj, Object value)
```
参数：
- obj：要修改属性值的具体对象；
- value：具体要修改的值。
获取值：
```
1Object get(Object obj)
```
参数：
- obj：要修改属性值的具体对象。

Example：

 1public class Student {
 2    public String name;
 3    private int age;
 4    private String gender;
 5    private String address;
 6
 7    public Student(String name, int age, String gender, String address) {
 8        this.name = name;
 9        this.age = age;
10        this.gender = gender;
11        this.address = address;
12    }
13}

 1public class ReflectDemo {
 2    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchFieldException {
 3        Student student = new Student("张三", 23, "大三", "广州");
 4
 5        // 获取Class对象
 6        Class<?> clazz = Class.forName("com.linner.reflect.Student");
 7
 8        // 获取并修改name的值
 9        Field nameField = clazz.getField("name");
10        // 获取name的值
11        String name = (String) nameField.get(student);
12        System.out.println(name);
13        // 修改name的值
14        nameField.set(student, "李四");
15        name = (String) nameField.get(student);
16        System.out.println(name);
17
18        System.out.println("===============");
19
20        // 获取并修改私有变量的值（暴力反射）
21        Field addressField = clazz.getDeclaredField("address");
22        // 临时取消访问权限（获取和修改私有变量的值都需要此操作）
23        addressField.setAccessible(true);
24        // 获取私有变量address的值
25        String address = (String) addressField.get(student);
26        System.out.println(address);
27        // 修改私有变量address的值
28        addressField.set(student, "北京");
29        address = (String) addressField.get(student);
30        System.out.println(address);
31    }
32}

获取成员方法

获取成员方法即为获取Method对象。

方法名	说明
`Method[] getMethods()`	返回所有公共成员方法对象（`public`）
`Method[] getDeclaredMethods()`	放回所有成员方法对象（包括`private`）
`Method getMethod(String name, Class<?>... parameterTypes)`	返回指定名称和形参的公共成员方法对象（`public`）
`Method getDeclaredMethod(String name, Class<?>... parameterTypes`	返回指定名称和形参的成员方法对象（包括`private`）

Example：

 1package com.linner.reflect;
 2
 3public class Student {
 4    private String name;
 5    private int age;
 6    private String gender;
 7    private String address;
 8
 9    public Student() {
10
11    }
12
13    public Student(String name) {
14        this.name = name;
15    }
16
17    public Student(String name, int age) {
18        this.name = name;
19        this.age = age;
20    }
21
22    public Student(String name, int age, String gender, String address) {
23        this.name = name;
24        this.age = age;
25        this.gender = gender;
26        this.address = address;
27    }
28
29    public String getName() {
30        return name;
31    }
32
33    public void setName(String name) {
34        this.name = name;
35    }
36
37    public int getAge() {
38        return age;
39    }
40
41    public void setAge(int age) {
42        this.age = age;
43    }
44
45    public String getGender() {
46        return gender;
47    }
48
49    public void setGender(String gender) {
50        this.gender = gender;
51    }
52
53    public String getAddress() {
54        return address;
55    }
56
57    public void setAddress(String address) {
58        this.address = address;
59    }
60
61    @Override
62    public String toString() {
63        return "Student{" +
64                "name='" + name + '\'' +
65                ", age=" + age +
66                ", gender='" + gender + '\'' +
67                ", address='" + address + '\'' +
68                '}';
69    }
70
71    private void sleep() {
72        System.out.println(this.name + "正在睡觉");
73    }
74
75    private void study() {
76        System.out.println(this.name + "正在内卷");
77    }
78
79    private void study(int time) {
80        System.out.println(this.name + "已经卷了" + time + "分钟还在卷");
81    }
82}

 1public class ReflectDemo1 {
 2    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
 3        // 获取Class对象
 4        Class<?> clazz = Class.forName("com.linner.reflect.Student");
 5
 6        // 获取所有公共成员方法
 7        Method[] methods1 = clazz.getMethods();
 8        for (Method method : methods1) {
 9            System.out.println(method);
10        }
11
12        System.out.println("==============");
13
14        // 获取所有成员方法（包括private）
15        Method[] methods2 = clazz.getDeclaredMethods();
16        for (Method method : methods2) {
17            System.out.println(method);
18        }
19
20        System.out.println("==============");
21
22        // 获取指定的公共成员方法
23        // 空参的公共成员方法
24        Method toStringMethod = clazz.getMethod("toString");
25        System.out.println(toStringMethod);
26        // 带参数的公共成员方法
27        Method setNameMethod = clazz.getMethod("setName", String.class);
28        System.out.println(setNameMethod);
29
30        System.out.println("==============");
31
32        // 获取指定的成员方法（包括private）
33        // 空参的成员方法
34        Method studyMethod1 = clazz.getDeclaredMethod("study");
35        System.out.println(studyMethod1);
36        // 带参数的成员方法
37        Method studyMethod2 = clazz.getDeclaredMethod("study", int.class);
38        System.out.println(studyMethod2);
39    }
40}

通过反射运行成员方法

使用Method对象的invoke()方法可以运行成员方法。

1Object invoke(Object obj, Object... args)

obj：具体调用成员方法的对象；
args：调用成员方法传递的参数；
返回值：方法的返回值。

Example：

 1public class ReflectDemo1 {
 2    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
 3        Student student = new Student("张三", 23, "大三", "广州");
 4
 5        // 获取Class对象
 6        Class<?> clazz = Class.forName("com.linner.reflect.Student");
 7
 8        // 调用无参的成员方法
 9        Method toStringMethod = clazz.getMethod("toString");
10        String studentToString = (String) toStringMethod.invoke(student);
11        System.out.println(studentToString);
12
13        // 调用带参的私有成员方法
14        Method studyMethod = clazz.getDeclaredMethod("study", int.class);
15        // 临时取消访问权限
16        studyMethod.setAccessible(true);
17        studyMethod.invoke(student, 180);
18    }
19}

注解

Java注解是附加在代码中的一些元信息，用于编译和运行时进行解析和使用，起到说明、配置的功能。

注解不会影响代码的实际逻辑（并不直接影响代码的语义），仅仅起到辅助性的作用（但是注解可以被看做是程序的工具或者类库。会反过来对正在运行的程序语义有所影响）。包含在java.lang.annotation包中。注解使用@interface来定义（类似于接口的定义）。为注解定义一个方法即为注解类型定义了一个元素，方法的声明不允许有参数或throw语句，返回值类型被限定为原始数据类型、String、Class、enums、注解类型，或前面这些类型的数组，方法可以有默认值。注解可以从源文件、class文件或者在运行时通过反射机制多种方式被读取。

注解的实现的原理很大的一部分是基于反射实现。

一般来说，注解一般分为三种类型：

元注解
标准注解
自定义注解

元注解

元注解是专职负责注解其他注解，主要是标明该注解的使用范围，生效范围。元注解并不能被修改，只能被用来定义自定义注解。

元注解包括以下四种：

注解	说明
`@Target`	定义注解的作用目标。即用来定义自定义注解具体作用在类上，方法上，还是变量上。具体值和作用对象如下： `ElementType.TYPE`：接口、类、枚举、注解 `ElementType.FIELD`：字段、枚举的常量 `ElementType.METHOD`：方法 `ElementType.PARAMETER`：方法参数 `ElementType.CONSTRUCTOR`：构造函数 `ElementType.LOCAL_VARIABLE`：局部变量 `ElementType.ANNOTATION_TYPE`：注解 `ElementType.PACKAGE`：包
`Retention`	定义注解的保留策略。该注解的值如下： `RetentionPolicy.SOURCE`：定义注解仅存在于源码中，在class字节码文件中不包含； `RetentionPolicy.CLASS`：该注解默认的保留策略，定义注解会在class字节码文件中存在，但运行时无法获得； `RetentionPolicy.RUNTIME`：定义注解会在class字节码文件中存在，在运行时可以通过反射获取到。
`@Document`	说明该注解将被包含在javadoc中。
`@Inherited`	说明子类可以继承该注解。

标准注解

Java 提供了三个标准注解，定义在java.lang中（这三个注解的作用更多是一种注释）。

@Override：表示当前方法覆盖了父类中的对应方法（重写方法）。
@Deprecated：标记一个元素为已过期，避免或不推荐使用。

支持的元素类型为：CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE。
@SuppressWarnings：不输出对应的编译警告。

自定义注解

注解的定义类似于接口的定义，使用@interface来定义。定义注解类中的一个方法即为注解类型定义了一个元素，方法的声明不允许有参数或throw语句，返回值类型被限定为原始数据类型、字符串String、Class、enums、注解类型，或前面这些类型的数组，方法可以有默认值。

自定义注解一般分为以下三个步骤：

定义注解。

如：

1@Target(ElementType.Type)   // 表明该注解加载在类上
2@Retention(RetentionPolicy.RUNTIME) // 表明运行时读取该注解
3// 定义注解类
4public @interface MyAnnotationType {
5    // 定义注解方法（不能有参数或throw等）
6    String value();
7}

1@Target(ElementType.FIELD)   // 表明该注解加载在字段上（接口、类、枚举）。
2@Retention(RetentionPolicy.RUNTIME)
3public @interface MyAnnotationField {
4    String name();
5    // 使用default定义默认值
6    int length() default 0;
7}

使用注解。

如（在其他类上）：

1@MyAnnotationType("Annotation")
2// 或（有多个元素时需要指定元素名）：@MyAnnotation1(value = "Annotation")
3public class UsingAnnotations {
4    @MyAnnotationField(name = "张三", length = 12)
5    public int a;
6    @MyAnnotationField(name = "李四")   // length将使用默认值
7    public String b;
8}

读取注解。

如（定义一个类来读取）：

 1public class AnnotationValues {
 2    public static void readValues() throws ClassNotFoundException {
 3        Class usingAnnotationsClass = Class.forName("UsingAnnotation");
 4
 5        // 读取作用于类上的注解
 6        MyAnnotationType mat = (MyAnnotationType) usingAnnotationsClass.getAnnotation(MyAnnotationType.class);
 7        System.out.println(mat.value());
 8
 9        // 读取作用于属性上的注解
10        Field a = usingAnnotationsClass.getDeclaredField("a");
11        MyAnnotationField maf = (MyAnnotationField) a.getAnnotation(MyAnnotationField.class);
12        System.out.println(maf.name());
13        System.out.println(maf.length());
14    }
15}

使用注解模拟 Junit

 1public class AnnotationDemo {
 2
 3    // @MyTest
 4    public void test1() {
 5        System.out.println("test1...");
 6    }
 7
 8    @MyTest
 9    public void test2() {
10        System.out.println("test2...");
11    }
12
13    // @MyTest
14    public void test3() {
15        System.out.println("test3...");
16    }
17
18    @MyTest
19    public void test4() {
20        System.out.println("test4...");
21    }
22
23    @MyTest
24    public void test5() {
25        System.out.println("test5...");
26    }
27
28    public static void main(String[] args) throws Exception {
29        AnnotationDemo a = new AnnotationDemo();
30
31        // 获取Class对象
32        Class<?> clazz = Class.forName("com.linner.annotation.AnnotationDemo");
33
34        // 判断对象的所有方法上是否存在MyTest注解
35        Method[] methods = clazz.getDeclaredMethods();
36        for (Method method : methods) {
37            if (method.isAnnotationPresent(MyTest.class)) {
38                method.invoke(a);
39            }
40        }
41    }
42
43}

Java 反射

目录

反射

获取字节码文件对象

获取构造方法

通过反射创建对象

获取成员变量

利用反射获取和修改成员变量的值

获取成员方法

通过反射运行成员方法

注解

元注解

标准注解

自定义注解

使用注解模拟 Junit

版权

评论

Java 反射

目录

反射

获取字节码文件对象

获取构造方法

通过反射创建对象

获取成员变量

利用反射获取和修改成员变量的值

获取成员方法

通过反射运行成员方法

注解

元注解

标准注解

自定义注解

使用注解模拟 Junit

版权

相关文章

评论