头歌Educoder——Java高级特性 - Java反射_java高级特性,java反射头歌

第1关：了解 Class 对象

任务描述

本关任务：实现获取Class对象的三种方式

相关知识

为了完成本关任务，你需要掌握：

1. Class对象；
2. 三种获取Class类型的实例的方法；
   1. 通过Object类中的getClass()方法；
   2. 通过静态方法Class.forName("全类名")；
   3. 通过类字面常量Class.class。
3. 三种方法获取的Class对象之间的区别。

Class 对象

1. 在程序运行期间，Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识(RTTI)。这个信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行。保存这些信息的类被称为Class，可以通过专门的Java类访问这些信息。
2. Class类的实例表示正在运行的Java应用程序中的类和接口。其中枚举是一种特殊的类，注释是一种特殊的接口。每个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象基本的Java类型（boolean、byte、char、short、int、long、float和double）和关键字void也表示为Class对象。
3. Class对象就是用来创建类的所有的”常规”对象的。每个类都有一个Class对象,每当编写一个并且编译了一个新类，就会产生一个Class对象(保存在体同名的 .class 文件中)。
4. Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

三种获取Class类型的实例的方法

方法1：通过Object类中的getClass()方法返回一个Class类型的实例

示例如下：

Person person = new Person();
Class clazz = person.getClass();
1
2

方法2：通过静态方法Class.forName("全类名")获取类名对应的Class对象

Class.forName()方法原型：

public static Class<?> forName(String className) throws ClassNotFoundException
1

若无法根据类路径className找到对应的 .class 文件会抛出 ClassNotFoundException异常，因此使用forName()方法需要捕获异常或向上抛出异常。

示例如下：

Class clazz = null;
String className = "step1.Person";
try {
    clazz = Class.forName(className);
} catch(ClassNotFoundException e) {
}
1
2
3
4
5
6

方法3：通过类字面常量Class.class获取

示例如下：

Class clazz = Person.class;
1

该方法不仅更简单，而且更安全，因为它在编译时就会受到检查(因此不需要置于try语句块中)。并且它根除了对forName()方法的调用，所以更高效。

三种方法获取的 Class 对象之间的区别

每个类都有一个Class对象，因此对于某个类使用三种方式获取的 Class对象都是相等。

编程要求

请仔细阅读右侧代码，结合相关知识，在Begin-End 区域内进行代码补充，完成三个方法getPersonClass1()、getPersonClass2()、getPersonClass3()的代码编写，要求分别使用三种方式获取Person类的Class对象并返回。 注意：无需修改main()方法的输出内容。

测试说明

平台会对你编写的代码进行测试：

预期输出：

通过Object 类中的 getClass() 获取的 Class 对象为：class step1.Person

通过静态方法 Class.forName() 获取的 Class 对象为：class step1.Person

通过类字面常量获取 Class 的对象为：class step1.Person

---

开始你的任务吧，祝你成功！

代码样例

Reflect_stu.java

package step1;

/**
 * 学员任务文件
 */
public class Reflect_stu {

	public static void main(String[] args) {
		System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
		System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
		System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
	}

	/**
	 * 通过 Object 类中的 getClass() 获取的 Class 对象
	 *
	 * @return
	 */
	public static Class getPersonClass1() {
		/********** Begin *********/
		Person person = new Person();
		Class clazz1 = person.getClass();

		return clazz1;
		/********** End *********/
	}

	/**
	 * 通过静态方法 Class.forName() 获取的 Class 对象
	 * <p>
	 * 注意：Person 类的全路径为: step1.Person
	 *
	 * @return
	 */
	public static Class getPersonClass2() {
		/********** Begin *********/
		String className = "step1.Person";
		Class clazz2 = null;
		try {
			clazz2 = Class.forName(className);
		} catch (ClassNotFoundException e) {
		}

		return clazz2;
		/********** End *********/
	}

	/**
	 * 通过类字面常量获取 Class 的对象
	 *
	 * @return
	 */
	public static Class getPersonClass3() {
		/********** Begin *********/
		Class clazz3 = Person.class;

		return clazz3;
		/********** End *********/
	}
}

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

Reflect_run.java

package step1;

/**
 * 评测执行文件
 */

public class Reflect_run {

    public static void main(String[] args) {
//        Class clazz1 = Person.class;
        2、通过对象的getClass()方法返回一个Class类型的实例
//        Person person = new Person();
//        Class clazz2 = person.getClass();
        3、通过静态方法Class.forName()获取类名对应的Class对象
//        Class clazz3 = null;
//        try {
//            clazz3 = Class.forName("step1.Person");
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//
//        // 使用 "==" 进行比较 clazz1 与 clazz2 的关系
//        System.out.println(clazz1 == clazz2);
//        // 使用 "==" 进行比较 clazz2 与 clazz3 的关系
//        System.out.println(clazz2 == clazz3);
        System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
        System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
        System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
    }

    /**
     * 通过 Object 类中的 getClass() 获取的 Class 对象
     *
     * @return
     */
    public static Class getPersonClass1() {
        return new Person().getClass();
    }

    /**
     * 通过静态方法 Class.forName() 获取的 Class 对象
     *
     * @return
     */
    public static Class getPersonClass2() {
        Class clazz = null;
        try {
            clazz = Class.forName("step1.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return clazz;
    }

    /**
     * 通过类字面常量获取 Class 的对象
     *
     * @return
     */
    public static Class getPersonClass3() {
        return Person.class;
    }
}

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

Person.java

package step1;

public class Person {

}

1
2
3
4
5
6

第2关：利用反射分析类的能力

任务描述

本关任务：利用反射获取Apple类的的所有的方法和构造器签名，以及全部域名。

相关知识

为了完成本关任务，你需要回顾上节所学Class对象的相关知识, 以及需要掌握以下知识：

1. 反射的基本概念；
2. Class对象与反射之间的关系；
3. Class的类结构；
4. 利用反射分析类的能力。

反射的基本概念

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

Class 对象与反射之间的关系

Java 反射机制允许程序在运行时取得任何一个已知名称的Class 的内部信息，包括其 modifiers(修饰符)、fields(属性)，methods(方法)等，并可于运行时改变 fields 内容或调用 methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！

Class 的类结构

在java.lang.reflect包中有三个类Field、Method和Constructor分别用于描述类的域、方法和构造器。Class类中的getFields()、getMethods()和getConstructors()方法将分别返回类提供的 public 域、方法和构造器，其中包括超类的共有成员。Class类中的getDeclareFields()、getDeclareMethods()和getDeclareConstructors()方法将分别返回类中声明的全部域、方法和构造器，其中包括私有和受保护的成员，但不包括超类的成员。

如：

public Field[] getFields() throws SecurityException
public Method[] getMethods() throws SecurityException
public Constructor<?>[] getConstructors() throws SecurityException
1
2
3

利用反射分析类的能力

通过获取某个类的Class对象，并通过Class类的 getFields()、getMethods()和getConstructors()获得所有域、方法和构造器。

示例:

class Person {
    public String name;
    String sex;
    protected String height;
    private int age;
    public Person() {
    }
    private Person(String name) {
        this.name = name;
    }
    public Person(String name, String sex, String height, int age) {
        ...省略
    }
}
public static void main(String[] args) {
    Person person = new Person();
    printConstructors(person.getClass());
}
public static void printConstructors(Class clazz) {
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            String name = constructor.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(constructor.getModifiers());
            if (modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(name + "(");
            Class[] paramTypes = constructor.getParameterTypes();
            for (int j = 0; j < paramTypes.length; ++j) {
                if (j > 0) {
                    System.out.print(",");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

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

输出结果：

public Person();

public Person(java.lang.String,java.lang.String,java.lang.String,int);

编程要求

请仔细阅读右侧代码，结合相关知识，在Begin-End 区域内进行代码补充，打印Apple类的所有public 域、方法和构造器。已分别提供了方法声明printConstructors、printFields、printMethods，请将代码补充完整，且按照打印格式要求输出。

提示：

1. Method.getReturnType()可以获得方法的返回类型。
2. 打印方法或域的修饰符可以调用提供的printModifiers()方法
3. 打印方法的参数可以调用提供的printParamTypes()方法
4. Field的getType方法可以获得域类型、getName方法可以获得域的名称

测试说明

预期输出：

private java.lang.String name;

public step2.Apple();

public step2.Apple(java.lang.String);

public void setName(java.lang.String);

平台会对你编写的代码进行测试。

---

开始你的任务吧，祝你成功！

代码样例

Reflect_stu.java

package step2;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

class Apple {
	private String name;

	public Apple() {
	}

	public Apple(String name) {
	}

	public void setName(String name) {
		this.name = name;
	}
}

public class Reflect_stu {

	public static void main(String[] args) {
		// 请根据提供的 classPath 获取 step2.Apple 的 Class 对象， 请使用 Class.forName() 方法， 注意捕获异常
		// 通关之后，你也可以修改 clasapath 为其他类路径，分析某个类的能力， 例如: java.util.Date
		String classPath = "step2.Apple";
		Class clazz = null;
		/********** Begin *********/
		try {
			clazz = Class.forName(classPath);

		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

		/********** End *********/
		printFields(clazz);
		printConstructors(clazz);
		printMethods(clazz);
	}

	/**
	 * 请打印类的每个域,输出格式为：修饰符 类型 变量名;
	 * 
	 * @param clazz
	 */
	public static void printFields(Class clazz) {
		/********** Begin *********/
		try {
			Field[] fields = clazz.getDeclaredFields();
			for (Field field : fields) {
				System.out.print(Modifier.toString(field.getModifiers()) + " ");
				System.out.print(field.getType().getTypeName() + " ");
				System.out.println(field.getName() + ";");
			}
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

		/********** End *********/
	}

	/**
	 * 打印构造函数,输出格式为：修饰符 方法名称（参数）
	 * 
	 * @param clazz
	 */
	public static void printConstructors(Class clazz) {
		Constructor[] constructors = clazz.getDeclaredConstructors();
		for (Constructor constructor : constructors) {
			Class[] paramTypes = null;
			/********** Begin *********/

			paramTypes = constructor.getParameterTypes();

			System.out.print(Modifier.toString(constructor.getModifiers()) + " ");
			System.out.print(constructor.getName() + "(");

			/********** End *********/
			printParamTypes(paramTypes);
		}
	}

	/**
	 * 请针对每个方法打印其签名，格式为：修饰符 返回值类型 方法名称(参数);
	 * 
	 * @param clazz
	 */
	public static void printMethods(Class clazz) {
		Method[] methos = clazz.getDeclaredMethods();
		for (Method method : methos) {
			Class[] paramTypes = null;
			/********** Begin *********/

			paramTypes = method.getParameterTypes();

			System.out.print(Modifier.toString(method.getModifiers()) + " " + method.getReturnType().getName() + " "
					+ method.getName() + "(");

			/********** End *********/
			printParamTypes(paramTypes);
		}
	}

	/**
	 * 打印方法参数
	 * 
	 * @param paramTypes
	 */
	private static void printParamTypes(Class[] paramTypes) {
		for (int j = 0; j < paramTypes.length; ++j) {
			if (j > 0) {
				System.out.print(",");
			}
			System.out.print(paramTypes[j].getName());
		}
		System.out.println(");");
	}

}

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

Reflect_run.java

package step2;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Reflect_run {

    public static void main(String[] args) {
        // 请根据提供的 classPath 获取 step2.Apple 的 Class 对象
        String classPath = "step2.Apple";
        Class clazz = null;
        try {
            clazz = Class.forName(classPath);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        printConstructors(clazz);
        printFields(clazz);
        printMethods(clazz);
    }

    public static void printConstructors(Class clazz) {
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            String name = constructor.getName();
            printModifiers(clazz);
            System.out.print(name + "(");

            Class[] paramTypes = constructor.getParameterTypes();
            printParamTypes(paramTypes);
        }
    }

    private static void printModifiers(Class clazz) {
        System.out.print("  ");
        String modifiers = Modifier.toString(clazz.getModifiers());
        if (modifiers.length() > 0) {
            System.out.print(modifiers + " ");
        }
    }

    public static void printMethods(Class clazz) {
        Method[] methos = clazz.getDeclaredMethods();
        for (Method method : methos) {
            Class returnType = method.getReturnType();
            String name = method.getName();
            printModifiers(clazz);
            System.out.print(returnType.getName() + " " + name + "(");
            Class[] paramTypes = method.getParameterTypes();
            printParamTypes(paramTypes);
        }
    }

    private static void printParamTypes(Class[] paramTypes) {
        for (int j = 0; j < paramTypes.length; ++j) {
            if (j > 0) {
                System.out.print(",");
            }
            System.out.print(paramTypes[j].getName());
        }
        System.out.println(");");
    }

    public static void printFields(Class clazz) {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            Class type = field.getType();
            String name = field.getName();
            printModifiers(clazz);
            System.out.println(type.getName() + " " + name + ";");
        }
    }
}

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

Person.java

package step2;

public class Person {

    public String name;
    protected String height;
    String sex;
    private int age;

    public Person() {}

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, String sex, String height, int age) {
        this.name = name;
        this.sex = sex;
        this.height = height;
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getHeight() {
        return height;
    }

    public void setHeight(String height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

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

第3关：在运行时使用反射分析对象

任务描述

本关任务：完成一个可供任意类使用的通用toString(Object)方法。

相关知识

为了完成本任务，你需要掌握：

1. 如何通过Field类的get方法获取对象域；
2. 如何绕过 Java 安全访问控制获取私有对象域；
3. 获取对象域时数值类型如何处理。

如何通过 Field 类的 get 方法获取对象域

利用反射机制可以查看在编译时还不清楚的对象域。而查看对象域的关键方法就是Field类中的get方法。

如果f是一个Field类型的对象(例如，通过getDeclaredFields() 得到的对象),obj是一个包含f域的类的对象， 那么f.get(obj)将返回一个对象，其值为obj域的当前值。如此就可以在运行时获得对象的域。

示例：

class Person {
    public Integer weight;
    private Integer age;
    private double height;
    // 省略构造器、setter 和 getter 方法
}
public void test() {
    Person person = new Person(123, 19);
    Class clazz = person.getClass();
    Field field = clazz.getDeclaredField("weight");
    Object name = field.get(person);
    System.out.println(name); // 其打印结果为: "123"
}
1
2
3
4
5
6
7
8
9
10
11
12
13

如何绕过 Java 安全访问控制获取私有对象域

那如果要获取对象的私有域呢，例如，要获取Perso小明的年龄呢，直接修改上面示例为getDeclaredField("age")可以吗。答案是，不行，因为age是一个私有域，所以get方法会抛出一个 IllegalAccessException异常。

只有利用get方法才能得到可访问域的值。除非拥有访问权限，Java 安全机制只允许查看任意对象有哪些域，而不允许读取它们的值。

反射机制的默认行为受限于 Java 的访问控制。然而，如果一个 Java程序没有收到安全管理器的控制，就可以覆盖访问控制。调用 Field、Method或Constructor对象的setAccessible 方法可以突破这种限制。

示例：

public void test() {
    Person person = new Person(123, 19, 175);
    Class clazz = person.getClass();
    Field field = clazz.getDeclaredField("age");
    // 获取私有域的访问权限
    field.setAccessible(true);
    Object name = field.get(person);
    System.out.println(name); // 其打印结果为: "19"
}
1
2
3
4
5
6
7
8
9

获取对象域时数值类型如何处理

get方法还有一个要解决的问题。name域是一个String，因此可以作为Object返回。但是，如果要查看height域，它属于double类型，而 Java 中数值类型不是对象。因此要使用Field的其他 getXXX() 方法。反射机制会自动的将这个域值打包到相应的对象包装器中。

编程要求

请仔细阅读右侧代码，结合相关知识，在Begin-End 区域内进行代码补充，完成通用toString()方法。

提示：

快速设置访问权限: ``AccessibleObject.setAccessible(fields, true); ``
获得所有域:``Class.getDeclaredFields()``
1
2

测试说明

平台会对你编写的代码进行测试。

示例：

public static void toString(Object obj) {
    // 请完成代码
}
public static void main(String[] args) {
    Person person = new Person(123, 19, 175);
    toString(person);
}
1
2
3
4
5
6
7

预期输出： [weight=[value=123],age=[value=19],height=[value=175.0]]

---

开始你的任务吧，祝你成功！

代码示例

Reflect_stu.java

package step3;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Reflect_stu {

	public static String toString(Object obj) {
		Class cl = obj.getClass();
		String r = "";
		r += "[";

		// 请获取所有 Field 并设置访问权限为 true
		/********** Begin *********/
		Field[] fields = null;
		fields = cl.getDeclaredFields();
		AccessibleObject.setAccessible(fields, true);

		/********** End *********/
		for (Field f : fields) {
			// 此处 if，逻辑为判断 Field 域是否为非静态域
			if (!Modifier.isStatic(f.getModifiers())) {
				if (!r.endsWith("["))
					r += ",";
				r += f.getName() + "=";
				try {
					// 请获取域的类型及值
					/********** Begin *********/

					Class t = null;
					Object val = null;
					t = f.getType();
					val = f.get(obj);

					/********** End *********/
					// isPrimitive() 用于判断是否为基本数据类型，若为基础数据类型直接拼接，否则递归调用 toString 方法
					if (t.isPrimitive())
						r += val;
					else
						r += toString(val);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		r += "]";
		return r;
	}

	public static void main(String[] args) {
		Person person = new Person(88, 19, 175);
		System.out.println(toString(person));
	}
}

class Person {
	public Integer weight;
	private Integer age;
	private Double height;

	public Person(Integer weight, Integer age, double height) {
		this.weight = weight;
		this.age = age;
		this.height = height;
	}
}

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

Reflect_run.java

package step3;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Reflect_run {

    public static String toString(Object obj) {
        Class cl = obj.getClass();
        String r = "";
        r += "[";
        Field[] fields = cl.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);
        for (Field f : fields) {
            if (!Modifier.isStatic(f.getModifiers())) {
                if (!r.endsWith("[")) r += ",";
                r += f.getName() + "=";
                try {
                    Class t = f.getType();
                    Object val = f.get(obj);
                    if (t.isPrimitive()) r += val;
                    else r += toString(val);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        r += "]";
        return r;
    }


    public static void main(String[] args) {
        Person person = new Person(88, 19, 175);
        System.out.println(toString(person));
    }

}

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

第4关：利用反射进行方法调用

任务描述

本关任务：利用反射创建对象并调用其方法。

相关知识

为了完成本关任务，你需要掌握：

1. 如何通过反射创建对象；
2. 如何通过反射调用对象方法。

如何通过反射创建对象

反射创建类对象主要有两种方式，通过Class对象的newInstance()方法、通过Constructor对象的 newInstance()方法。

1. 第一种：通过Class对象的newInstance()方法。

   Class clazz = Apple.class;
   Apple apple = (Apple)clazz.newInstance();
   1
   2

2. 第二种：通过Constructor对象的newInstance()方法

   Class clazz = Apple.class;
   Constructor constructor = clazz.getConstructor();
   Apple apple = (Apple)constructor.newInstance();
   1
   2
   3

通过Constructor对象创建类对象可以选择特定构造方法，而通过 Class对象则只能使用默认的无参数构造方法。

示例：(调用有参构造方法进行类对象的初始化)

Class clz = Apple.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
Apple apple = (Apple)constructor.newInstance("红富士", 15);
1
2
3

如何通过反射调用对象方法

利用Method的invoke方法可以调用执行对象obj的方法

参数： obj 表示要调用的Method方法对象。 args 表示要调用的方法的参数，是可变长参数类型。

示例：

// 获取类的 Class 对象实例
Class clz = Class.forName("Apple");
// 根据 Class 对象实例获取 Constructor 对象
Constructor appleConstructor = clz.getConstructor();
// 使用 Constructor 对象的 newInstance 方法获取反射类对象
Object appleObj = appleConstructor.newInstance();
// 而如果要调用某一个方法，则需要经过下面的步骤：
// 1、获取方法的 Method 对象
Method setPriceMethod = clz.getMethod("setPrice", int.class);
// 2、用 invoke 方法调用方法
setPriceMethod.invoke(appleObj, 14);
class Apple {
    public void setPrice(int price) {
        //省略
    }
    // 省略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

编程要求

请仔细阅读右侧代码，结合相关知识，在Begin-End 区域内进行代码补充，使用反射调用 Apple 类的 setPrice()方法，设置苹果价格为 14，并打印价格。接着还要用反射去调用getTotal方法获取单价为 20，数量 24 的总金额并打印。

测试说明

预期输出：

14.0

480.0

平台会对你编写的代码进行测试。

---

开始你的任务吧，祝你成功！

代码示例

Reflect_stu.java

package step4;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Reflect_stu {
	public static void main(String[] args) throws InvocationTargetException {
		// 使用反射调用
		Class clazz = null;
		try {
			clazz = Class.forName("step4.Apple");
			/********** Begin *********/
			Constructor cons = clazz.getConstructor();
			Apple apple = (Apple) cons.newInstance();

			Method method = clazz.getMethod("setPrice", double.class);
			method.invoke(apple, 14);

			Method getPrice = clazz.getMethod("getPrice");

			System.out.println(getPrice.invoke(apple));

			Method getTotal = clazz.getMethod("getTotal", double.class, int.class);

			System.out.println(getTotal.invoke(apple, 20, 24));

			/********** End *********/
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

class Apple {
	private double price;
	private int count;

	public Apple() {
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public double getTotal(double price, int count) {
		return price * count;
	}
}
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

Reflect_run.java

package step4;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Reflect_run {
    public static void main(String[] args) throws InvocationTargetException {
        //使用反射调用
        Class clazz = null;
        try {
            clazz = Class.forName("step4.Apple");
            Method setPriceMethod = clazz.getMethod("setPrice", double.class);
            Constructor appleConstructor = clazz.getConstructor();
            Object apple = appleConstructor.newInstance();
            setPriceMethod.invoke(apple, 20);
            Method getPriceMethod = clazz.getMethod("getPrice");
            System.out.println(getPriceMethod.invoke(apple));
            Method getTotal = clazz.getMethod("getTotal", double.class, int.class);
            System.out.println(getTotal.invoke(apple, 20, 24));
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}


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