Java 反射的应用

　　在学习反射之前，让我们先了解“类(Class)”。“方法”、“属性”、“类”都是名词，那么相应的在Java中会有这样一些特殊的类：“方法类(Method类)”、“属性类(Field类)”、“构造器类(Constructor类)”、“类类(Class类)”。

　　如上所示，任何Java的类或接口都是Class类的一个实例。

　　反射就是Java自我管理这些(类，对象)的机制。

　　1)　反射的作用

• • 可以通过反射机制发现对象的类型，发现类型的方法/属性/构造器
  • 可以创建对象并访问任意对象方法和属性等

　　2)　Class加载

　　　　类加载到内存：Java将磁盘类文件加载到内存中吗，为一个对象(实例)，这个对象是Class的实例。

　　3)　Class实例代表Java中类型

• • 获得基本类型实例
    • int.class
    • long.class
    • ...
  • 获得类类型(Class)实例：

Class cls = String.class;
Class cls = Class.forName("java.lang.String");
Class cls = "abc".getClass();

1.通过放射获得队形的类/属性/方法/构造器

【案例】反射演示_“发现”对象的类/属性/方法/构造器

• 版本01

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 反射演示
 */
public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        reflect("s");    //java.lang.String
        reflect(1);        //java.lang.Integer
    }

    /**
     * 反射方法，用于发现
     *         obj 的类型是什么
     *         obj 有哪些属性
     *         obj 有哪些方法
     *         obj 有哪些构造器
     * @param obj 表示被“反射”的对象，被用于“发现”的对象
     */
    public static void reflect(Object obj) {
        //1. getClass()
        //      返回对象的类型，是Object类的方法
        Class<?> cls = obj.getClass();
        System.out.println("类：" + cls.getName());
        //2. getDeclaredFields();
        //   返回在类上获得声明的所有属性(字段)
        Field[] fields = cls.getDeclaredFields();
        System.out.println("属性：");
        for(Field field : fields) {
            System.out.println(
                    field.getType()+" ：" + //属性类型
                    field.getName());        //属性名称
        }
        //3. getDeclaredMethods
        //   返回在类上获得声明的所有方法
        Method[] methods = cls.getDeclaredMethods();
        System.out.println("方法：");
        for(Method method : methods) {
            System.out.print(method.getReturnType()+" ");
            System.out.print(method.getName()+" ");
            System.out.println(
                    Arrays.toString(method.getParameterTypes()));
        }
        //4. getDeclaredConstructors
        //   返回在类上获得声明的所有构造器
        Constructor[] constructors = cls.getDeclaredConstructors();
        System.out.println("构造器：");
        for(Constructor c : constructors) {
            System.out.print(c.getName() + " ");
            System.out.println(
                    Arrays.toString(c.getParameterTypes()));
        }
    }

}

• 版本02

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 *反射演示
 */
public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        reflect(new Foo());    //reflect.Foo
    }

    /**
     * 反射方法，用于发现
     *         obj 的类型是什么
     *         obj 有哪些属性
     *         obj 有哪些方法
     *         obj 有哪些构造器
     * @param obj 表示被“反射”的对象，被用于“发现”的对象
     */
    public static void reflect(Object obj) {
        //1. getClass()
        //      返回对象的类型，是Object类的方法
        Class<?> cls = obj.getClass();
        System.out.println("类：" + cls.getName());
        //2. getDeclaredFields();
        //   返回在类上获得声明的所有属性(字段)
        Field[] fields = cls.getDeclaredFields();
        System.out.println("属性：");
        for(Field field : fields) {
            System.out.println(
                    field.getType()+" ：" + //属性类型
                    field.getName());        //属性名称
        }
        //3. getDeclaredMethods
        //   返回在类上获得声明的所有方法
        Method[] methods = cls.getDeclaredMethods();
        System.out.println("方法：");
        for(Method method : methods) {
            System.out.print(method.getReturnType()+" ");
            System.out.print(method.getName()+" ");
            System.out.println(
                    Arrays.toString(method.getParameterTypes()));
        }
        //4. getDeclaredConstructors
        //   返回在类上获得声明的所有构造器
        Constructor[] constructors = cls.getDeclaredConstructors();
        System.out.println("构造器：");
        for(Constructor c : constructors) {
            System.out.print(c.getName() + " ");
            System.out.println(
                    Arrays.toString(c.getParameterTypes()));
        }
    }

}
class Foo {
    int a = 3;
    public double add(int b, Double d) {
        return a+b+d;
    }

}

结果：

　　Java是如何知道程序员开发程序的类、属性、方法的？通过反射技术(反射技术是Java底层JVM运行程序的机制)

　　如下所示，Eclipse开发工具的“代码提示”功能就是利用反射写的。

2.通过发射创建对象实例

【案例】反射演示_根据类名创建对象实例

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 *反射演示
 */
public class Demo3 {
    public static void main(String[] args) throws Exception {
        //执行create()方法前提是参数类有无参构造器
        Object obj = create("reflect.Foo3");
        reflect(obj);
        reflect(create("java.lang.String"));
    }
    /**
     * 任务1：根据“类名”创建对象实例
     * @param className
     * @return
     */
    public static Object create(String className) {
        try {
            //1        加载类
            //1.1    在classpath中查找对应的类
            //1.2    采用“懒加载”方式装载到内存
            Class cls = Class.forName(className);
            //2        创建类实例
            Object obj = cls.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("没搞定!", e);
        }
    }

    /**
     * 反射方法，用于发现
     *         obj 的类型是什么
     *         obj 有哪些属性
     *         obj 有哪些方法
     *         obj 有哪些构造器
     * @param obj 表示被“反射”的对象，被用于“发现”的对象
     * @throws Exception
     */
    public static void reflect(Object obj) throws Exception {
        //1.    getClass()
        //        返回对象的类型，是Object类的方法
        Class<?> cls = obj.getClass();
        System.out.println("类：" + cls.getName());
        //2.    getDeclaredFields();
        //        返回在类上获得声明的所有属性(字段)
        Field[] fields = cls.getDeclaredFields();
        System.out.println("属性：");
        for(Field field : fields) {
            System.out.println(
                    field.getType()+" ：" + //属性类型
                    field.getName());        //属性名称
        }
        //3.    getDeclaredMethods
        //        返回在类上获得声明的所有方法
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods) {
            System.out.print(method.getReturnType()+" ");
            System.out.print(method.getName()+" ");
            System.out.println(
                    Arrays.toString(method.getParameterTypes()));
        }
        //4.    getDeclaredConstructors
        //        返回在类上获得声明的所有构造器
        Constructor[] constructors = cls.getDeclaredConstructors();
        System.out.println("构造器：");
        for(Constructor c : constructors) {
            System.out.print(c.getName() + " ");
            System.out.println(
                    Arrays.toString(c.getParameterTypes()));
        }
    }
}

class Foo3 {
    int a = 3;
    public double add(int b, Double d) {
        return a+b+d;
    }
}

注：

• Class.forName() 静态方法，可以利用类名在CLASSPATH中查找对应的类，并且装载到内存，返回这个“class”
• Class.forName() 加载类的过程采用“懒惰方式”
  • “懒惰方式”，即检查发现如果已经加载了(内存中存在)就不再加载，直接返回已经加载的类，相当于“手工”去检查内存在是否已经加载某个类
• newInstance() 方法，会利用默认(无参数)构造器创建类实例(实例对象)

3.通过反射访问某对象的某属性

【案例】反射演示_访问某对象的某属性

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 *反射演示
 */
public class Demo4 {
    public static void main(String[] args) throws Exception {
        //执行create()方法前提是参数类有无参构造器
        Object obj = create("reflect.Foo4");
        System.out.println(getFieldValue(obj, "a"));
    }
    /**
     * 任务1：根据“类名”创建对象实例
     * @param className
     * @return
     */
    public static Object create(String className) {
        try {
            //1        加载类
            //1.1    在classpath中查找对应的类
            //1.2    采用“懒加载”方式装载到内存
            Class cls = Class.forName(className);
            //2        创建类实例
            Object obj = cls.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("没搞定!", e);
        }
    }
    /**
     * 任务2：访问某对象的某属性
     * @param obj
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(
            Object obj, String fieldName) {
        try {
            //1.    反射出类型
            Class cls = obj.getClass();
            //2.    反射出类型字段
            Field field = cls.getDeclaredField(fieldName);
            //3.    在对象obj上读取field属性值
            Object val = field.get(obj);
            return val;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("没搞定!", e);
        }
    }
    /**
     * 反射方法，用于发现
     *         obj 的类型是什么
     *         obj 有哪些属性
     *         obj 有哪些方法
     *         obj 有哪些构造器
     * @param obj 表示被“反射”的对象，被用于“发现”的对象
     * @throws Exception
     */
    public static void reflect(Object obj) throws Exception {
        //1.    getClass()
        //        返回对象的类型，是Object类的方法
        Class<?> cls = obj.getClass();
        System.out.println("类：" + cls.getName());
        //2.    getDeclaredFields();
        //        返回在类上获得声明的所有属性(字段)
        Field[] fields = cls.getDeclaredFields();
        System.out.println("属性：");
        for(Field field : fields) {
            System.out.println(
                    field.getType()+" ：" + //属性类型
                    field.getName());        //属性名称
        }
        //3.    getDeclaredMethods
        //        返回在类上获得声明的所有方法
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods) {
            System.out.print(method.getReturnType()+" ");
            System.out.print(method.getName()+" ");
            System.out.println(
                    Arrays.toString(method.getParameterTypes()));
        }
        //4.    getDeclaredConstructors
        //        返回在类上获得声明的所有构造器
        Constructor[] constructors = cls.getDeclaredConstructors();
        System.out.println("构造器：");
        for(Constructor c : constructors) {
            System.out.print(c.getName() + " ");
            System.out.println(
                    Arrays.toString(c.getParameterTypes()));
        }
    }
}

class Foo4 {
    int a = 3;
    public double add(int b, Double d) {
        return a+b+d;
    }
}

注：

　　field.get(obj) 可以获得对象属性值

　　field.set(Object obj, Object value) 可以设置对象属性值

4.通过反射方位某对象的方法

【案例】反射演示_访问某对象的某方法

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 *反射演示
 */
public class Demo5 {
    public static void main(String[] args) throws Exception {
        //执行create()方法前提是参数类有无参构造器
        Object obj = create("reflect.Foo5");
        Object mObj = call(
                obj,                                     //obj
                "add",                                     //方法名
                new Class[]{int.class, Double.class},     //参数类型
                new Object[]{2, 3.5});                    //参数
        System.out.println(mObj);
    }
    /**
     * 任务1：根据“类名”创建对象实例
     * @param className
     * @return
     */
    public static Object create(String className) {
        try {
            //1        加载类
            //1.1    在classpath中查找对应的类
            //1.2    采用“懒加载”方式装载到内存
            Class cls = Class.forName(className);
            //2        创建类实例
            Object obj = cls.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("没搞定!", e);
        }
    }
    /**
     * 任务2：访问某对象的某属性
     * @param obj
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(
            Object obj, String fieldName) {
        try {
            //1.    反射出类型
            Class cls = obj.getClass();
            //2.    反射出类型字段
            Field field = cls.getDeclaredField(fieldName);
            //3.    在对象obj上读取field属性值
            Object val = field.get(obj);
            return val;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("没搞定!", e);
        }
    }

    /**
     * 任务3：访问某对象的某方法
     * @param obj            被调用对象
     * @param method        方法名
     * @param paramTypes    方法参数类型列表
     * @param params        方法调用参数列表
     * @return     在对象obj上调用方法签名是(method,paramTypes)的方法，
     *             params是传递的参数，返回的是方法的结果，
     *             如果无返回值，返回null
     */
    public static Object call(
            Object obj,
            String method,
            Class[] paramTypes,
            Object[] params) {
        try {
            //1.    发现类型
            Class cls = obj.getClass();
            //2.    发现方法
            Method m = cls.getDeclaredMethod(method, paramTypes);
            //3.    在对象obj调用方法m，传递参数类别params
            Object val = m.invoke(obj, params);
            return val;
        } catch(Exception e) {
            throw new RuntimeException("错误了!", e);
        }
    }

    /**
     * 反射方法，用于发现
     *         obj 的类型是什么
     *         obj 有哪些属性
     *         obj 有哪些方法
     *         obj 有哪些构造器
     * @param obj 表示被“反射”的对象，被用于“发现”的对象
     * @throws Exception
     */
    public static void reflect(Object obj) throws Exception {
        //1.    getClass()
        //        返回对象的类型，是Object类的方法
        Class<?> cls = obj.getClass();
        System.out.println("类：" + cls.getName());
        //2.    getDeclaredFields();
        //        返回在类上获得声明的所有属性(字段)
        Field[] fields = cls.getDeclaredFields();
        System.out.println("属性：");
        for(Field field : fields) {
            System.out.println(
                    field.getType()+" ：" + //属性类型
                    field.getName());        //属性名称
        }
        //3.    getDeclaredMethods
        //        返回在类上获得声明的所有方法
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods) {
            System.out.print(method.getReturnType()+" ");
            System.out.print(method.getName()+" ");
            System.out.println(
                    Arrays.toString(method.getParameterTypes()));
        }
        //4.    getDeclaredConstructors
        //        返回在类上获得声明的所有构造器
        Constructor[] constructors = cls.getDeclaredConstructors();
        System.out.println("构造器：");
        for(Constructor c : constructors) {
            System.out.print(c.getName() + " ");
            System.out.println(
                    Arrays.toString(c.getParameterTypes()));
        }
    }
}

class Foo5 {
    int a = 3;
    public double add(int b, Double d) {
        return a+b+d;
    }
}

注：

• 方法签名由方法名称与参数列表组成(没有返回值和访问控制符)，被成为方法签名
• call 方法标识，调用任意对象的任意方法
  • 调用无参方法时这样写：

PS:

getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。

getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。

java.lang.reflect.Method.invoke(Object obj, Object... args) invoke第一个参数obj，如果电泳的方法是static方法，obj参数可以传null。