头歌（educoder）第 5 章 Java 面向对象之类和对象 Java高级特性 - Java反射

目录

第1关：了解 Class 对象

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

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

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

---

第1关：了解 Class 对象

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 *********/
    }
}

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

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

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

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

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

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