您现在的位置是：首页 > Java

当前栏目

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

JAVA 对象反射代码

2023-03-02 10:30:56 时间

### 文章目录 ###

*  第1关：了解 Class 对象
 *   *  任务描述
     *  相关知识
     *   *  Class 对象
         *  三种获取Class类型的实例的方法
         *  三种方法获取的 Class 对象之间的区别
     *  编程要求
     *  测试说明
     *  代码样例
     *   *  Reflect\_stu.java
         *  Reflect\_run.java
         *  Person.java
 *  第2关：利用反射分析类的能力
 *   *  任务描述
     *  相关知识
     *   *  反射的基本概念
         *  Class 对象与反射之间的关系
         *  Class 的类结构
         *  利用反射分析类的能力
     *  编程要求
     *  测试说明
     *  代码样例
     *   *  Reflect\_stu.java
         *  Reflect\_run.java
         *  Person.java
 *  第3关：在运行时使用反射分析对象
 *   *  任务描述
     *  相关知识
     *   *  如何通过 \`Field\` 类的 \`get\` 方法获取对象域
         *  如何绕过 \`Java\` 安全访问控制获取私有对象域
         *  获取对象域时数值类型如何处理
     *  编程要求
     *  测试说明
     *  代码示例
     *   *  Reflect\_stu.java
         *  Reflect\_run.java
 *  第4关：利用反射进行方法调用
 *   *  任务描述
     *  相关知识
     *   *  如何通过反射创建对象
         *  如何通过反射调用对象方法
     *  编程要求
     *  测试说明
     *  代码示例
     *   *  Reflect\_stu.java
         *  Reflect\_run.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();

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

`Class.forName()`方法原型：

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

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

示例如下：

Class clazz = null;
    String className = "step1.Person";
    try { 
        clazz = Class.forName(className);
    } catch(ClassNotFoundException e) { 
    }

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

示例如下：

Class clazz = Person.class;

该方法不仅更简单，而且更安全，因为它在编译时就会受到检查(因此不需要置于`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 *********/
    	}
    }

### 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;
        }
    }

### Person.java ###

package step1;
    
    public class Person { 
    
    }

# 第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

### 利用反射分析类的能力 ###

通过获取某个类的`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(");");
            }
        }

输出结果：

`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(");");
    	}
    
    }

### 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 + ";");
            }
        }
    }

### 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;
        }
    }

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

## 任务描述 ##

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

## 相关知识 ##

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

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

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

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

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object</td> 
   <td>get(Object obj) 返回指定对象上此Field表示字段的值。</td> 
  </tr> 
 </tbody> 
</table>

如果`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"
    }

### 如何绕过 `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"
    }

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

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

<table> 
 <thead> 
  <tr> 
   <th>double</th> 
   <th>getDouble(Object obj) 获取double类型或另一个通过扩展转换可以转换为double类型的基本类型的静态或实例字段的值。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>float</td> 
   <td>getFloat(Object obj) 获取float类型或另一个通过扩展转换可以转换为float类型的基本类型的静态或实例字段的值。</td> 
  </tr> 
  <tr> 
   <td>Type</td> 
   <td>getGenericType() 返回一个Tpye对象，它表示此Field对象所表示字段的声明类型。</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>getInt(Object obj) 获取int类型或另一个通过扩展转换可以转换为int类型的基本类型的静态或实例字段的值。</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>getLong(Object obj) 获取long类型或另一个通过扩展转换可以转换为long类型的基本类型的静态或实例字段的值。</td> 
  </tr> 
 </tbody> 
</table>

## 编程要求 ##

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

提示：

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

## 测试说明 ##

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

示例：

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

预期输出： `[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;
    	}
    }

### 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));
        }
    
    }

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

## 任务描述 ##

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

## 相关知识 ##

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

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

### 如何通过反射创建对象 ###

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

1.  第一种：通过`Class`对象的`newInstance()`方法。
    
        Class clazz = Apple.class;
        Apple apple = (Apple)clazz.newInstance();
2.  第二种：通过`Constructor`对象的`newInstance()`方法
    
        Class clazz = Apple.class;
        Constructor constructor = clazz.getConstructor();
        Apple apple = (Apple)constructor.newInstance();

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

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

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

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

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

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>More ActionsObjectinvoke(Object obj,Object… args) 对带有指定参数的指定对象调用由此Method对象表示的底层方法。</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

参数： `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) { 
            //省略
        }
        // 省略
    }

## 编程要求 ##

请仔细阅读右侧代码，结合相关知识，在`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;
    	}
    }

### 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();
            }
        }
    }

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

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

相关文章