Java高级之反射（一）

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

Java反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

sun为我们提供了那些反射机制中的类：
java.lang.Class;
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;

话不多说，直接上代码

package com.java.framework.basis.reflect;

import com.java.framework.data_structure.adt.RationalImpl;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * Created by Ryan Xu on 2016/5/1.
 */
public class ReflectDemo {

    public static void main(String args[]) {

        Class<?> clazz = getClassMethods();

        testUsualMethods(clazz);
    }


    /**
     * 获取类类型的三种方式(用之前写的RationalImpl类举例)
     * 三种方式都可以
     */
    public static Class<?> getClassMethods() {
        Class<?> clazz = null;

        //1.通过Class的静态方法forName("packageName + className");
        try {
            clazz = Class.forName("com.java.framework.data_structure.adt.RationalImpl");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

//        //2.通过类的class属性
//        clazz = RationalImpl.class;
//
//        //3.通过RationalImpl的对象，调用getClass()方法获取
//        clazz = new RationalImpl(2,2).getClass();
        return clazz;
    }


    /**
     * 测试 Class常用的方法
     */
    public static void testUsualMethods(Class<?> clazz) {

        System.out.println("类名字：" + clazz.getName());
        System.out.println("包名：" + clazz.getPackage());

        //获取所有公开字段
        Field[] fields = clazz.getFields();
        for (Field f : fields) {
            System.out.println("公开字段：" + f.getName());
        }
        //获取所有字段包括私有
        Field[] privateFields = clazz.getDeclaredFields();
        for(Field f : privateFields) {
            System.out.println("所有字段：" + f.getName());
        }

        //获取具体的某一个字段，可以获取私有字段
        try {
            Field field = clazz.getDeclaredField("numerator");
            System.out.println("指定Field Name获取的字段：" + field.getName() + ", 字段类型：" + field.getType());
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        System.out.println("**********************Method**************************");

        //获取所有的公开的方法
        Method[] methods = clazz.getMethods();
        for (Method m : methods) {
            System.out.println("获取的所有公开的方法：" + m.getName() + ",方法访问修饰符：" + getAccessPermission(m.getModifiers()));
        }

        Method[] privateMethods = clazz.getDeclaredMethods();
        for (Method m : privateMethods) {
            System.out.println("获取所有的方法（include private） : " + m.getName() + "，访问权限：" + getAccessPermission(m.getModifiers()));
        }

        //通过方法名，指定获取具体的一个方法对象
        try {
            Method method = clazz.getDeclaredMethod("getCommonDivisor", int.class, int.class);
            RationalImpl r = new RationalImpl(2, 3);
            System.out.println("方法名：" + method.getName() );
            //Tips:通过Method对象的invoke方法，调用私有方法，一定要设置其访问权限为true，否则为报IllegalAccessException异常
            method.setAccessible(true);
            System.out.println("反射调用RationalImpl中的获取最大公约数的方法：value = " + method.invoke(r, 8, 72));
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        //构造方法对象Constructor
        try {
            Constructor constructor = clazz.getConstructor(int.class, int.class);
            RationalImpl r = (RationalImpl) constructor.newInstance(4,32);
            System.out.println("比较大小 ： " + r.compareTo(new RationalImpl(1, 8)));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param permission
     * @return
     */
    public static String getAccessPermission(int permission) {
        String accessPermission = "";
        switch(permission) {
            case Modifier.PUBLIC:
                accessPermission = "PUBLIC";
                break;
            case Modifier.PRIVATE:
                accessPermission = "PRIVATE";
                break;
        }
        return accessPermission;
    }

}

下面是运行结果：
类名字：com.java.framework.data_structure.adt.RationalImpl
包名：package com.java.framework.data_structure.adt
所有字段：numerator
所有字段：denominator
指定Field Name获取的字段：numerator, 字段类型：int
*****************Method*********************
获取的所有公开的方法：equals,方法访问修饰符：PUBLIC
获取的所有公开的方法：toString,方法访问修饰符：PUBLIC
获取的所有公开的方法：compareTo,方法访问修饰符：PUBLIC
获取的所有公开的方法：addition,方法访问修饰符：PUBLIC
获取的所有公开的方法：division,方法访问修饰符：PUBLIC
获取的所有公开的方法：getNumerator,方法访问修饰符：PUBLIC
获取的所有公开的方法：setNumerator,方法访问修饰符：PUBLIC
获取的所有公开的方法：subtraction,方法访问修饰符：PUBLIC
获取的所有公开的方法：setDenominator,方法访问修饰符：PUBLIC
获取的所有公开的方法：multiplication,方法访问修饰符：PUBLIC
获取的所有公开的方法：getDenominator,方法访问修饰符：PUBLIC
获取的所有公开的方法：wait,方法访问修饰符：
获取的所有公开的方法：wait,方法访问修饰符：
获取的所有公开的方法：wait,方法访问修饰符：
获取的所有公开的方法：equals,方法访问修饰符：PUBLIC
获取的所有公开的方法：hashCode,方法访问修饰符：
获取的所有公开的方法：getClass,方法访问修饰符：
获取的所有公开的方法：notify,方法访问修饰符：
获取的所有公开的方法：notifyAll,方法访问修饰符：
获取所有的方法（include private） : equals，访问权限：PUBLIC
获取所有的方法（include private） : toString，访问权限：PUBLIC
获取所有的方法（include private） : compareTo，访问权限：PUBLIC
获取所有的方法（include private） : trans，访问权限：PRIVATE
获取所有的方法（include private） : addition，访问权限：PUBLIC
获取所有的方法（include private） : division，访问权限：PUBLIC
获取所有的方法（include private） : getNumerator，访问权限：PUBLIC
获取所有的方法（include private） : setNumerator，访问权限：PUBLIC
获取所有的方法（include private） : subtraction，访问权限：PUBLIC
获取所有的方法（include private） : setDenominator，访问权限：PUBLIC
获取所有的方法（include private） : multiplication，访问权限：PUBLIC
获取所有的方法（include private） : getCommonDivisor，访问权限：PRIVATE
获取所有的方法（include private） : getDenominator，访问权限：PUBLIC
方法名：getCommonDivisor
反射调用RationalImpl中的获取最大公约数的方法：value = 8
比较大小 ： 0