Java高级特性之反射

原创于 2018-05-03 11:20:24 发布 · 234 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Java进阶

本文深入讲解Java反射机制，包括类的加载过程、反射的基本概念、Class类的理解与使用，以及如何通过反射获取构造器、成员变量和成员方法，并进行实例演示。

Java反射机制

_01 类加载器

A.类的加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
- a 加载：
  - 就是指将class文件读入内存，并为之创建一个Class对象。
  - 任何类被使用时系统都会建立一个Class对象
- b 连接：
  - 验证是否有正确的内部结构，并和其他类协调一致
  - 准备负责为类的静态成员分配内存，并设置默认初始化值
  - 解析将类的二进制数据中的符号引用替换为直接引用
- c 初始化：
  把.class文件对象加载到内存里，并把这个.class文件封装成一个Class类型的对象。

B.类的加载时机
以下的情况，会加载这个类：
- a. 创建类的实例
- b. 类的静态变量，或者为静态变量赋值
- c. 类的静态方法
- d. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- e. 初始化某个类的子类
- f. 直接使用java.exe命令来运行某个主类

C: 类加载器
负责将.class文件加载到内在中，并为之生成对应的Class对象。
- a. Bootstrap ClassLoader 根类加载器
  - 也被称为引导类加载器，负责Java核心类的加载
  - 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
- b. Extension ClassLoader 扩展类加载器
  - 负责JRE的扩展目录中jar包的加载
  - 在JDK中JRE的lib目录下ext目录
- c. System ClassLoader 系统类加载器
  - 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。
  - 我们用的是System ClassLoader 系统类加载器

_02 反射

1、反射简介：

A. 反射定义
- a. JAVA反射机制是在运行状态中
  
  对于任意一个类，都能够知道这个类的所有属性和方法；
  对于任意一个对象，都能够调用它的任意一个方法和属性；
  – – 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
- b.反射技术
  
  条件：运行状态
  已知：一个类或一个对象(本质是已知.class文件)
  结果：得到这个类或对象的所有方法和属性

注：要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

B. Class类
- a. Class类及Class对象的了解
  要想解剖一个类，必须先了解Class对象。
  Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
- b. 得到Class对象
  有三个方法:
  - 方式一： 通过Object类中的getClass()方法
    Person person = new Person();
    Class clazz = person.getClass();
  - 方式二：通过类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性）
    Class clazz = Person.class;
  - 方式三： 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）
    Class c3 = Class.forName(“Person”);

* 注：*第三种和前两种的区别是：
前两种你必须明确类类型.
后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了。

例：得到Class对象

// Person 类
public class Person {
    public String name;
    public int age;
    private String address;

    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("三参数构造器");
    }

    public Person() {
        System.out.println("public空参数构造器");
    }

    private Person(String name) {
        this.name = name;
        System.out.println("private   name 单参数构造器");
    }

    public void work(){
        System.out.println("Person is working");
    }

    private void sleep(){
        System.out.println("Person is sleeping");
    }
}

//测试
    @Test
    public void testReflect1() throws Exception{
        // 1. 通过Object类中的getClass()方法
        Person p1 = new Person();
        Class c1 = p1.getClass();  //c1 = class cn.itxiaobai.reflect.Person
        System.out.println("c1 = "+c1);

        // 2.  通过 类名.class 获取到字节码文件对象
        Class c2 = Person.class;
        System.out.println("c2 = "+c2);  //一样

        // 3. 反射中的方法
        Class c3 = Class.forName("cn.itxiaobai.reflect.Person");
        System.out.println("c3 = "+c3);  //一样

    }

注：Class 类型的唯一性
因为一个.class文件在内存里只生成一个Class对象，所以无论那一种方法得到Class对象，得到的都是同一个对象。

2、通过反射得到构造器并使用

例：通过反射获取无参构造方法:

    public void testReflect2() throws Exception{
        Class c = Class.forName("cn.itxiaobai.reflect.Person");
        /*
         * 使用class文件对象,获取类中的构造方法
         * Constructor[]  getConstructors() 获取class文件对象中的所有公共的构造方法
         */
         Constructor[] cons = c.getConstructors();
         for (Constructor constructor : cons) {
            System.out.println(constructor);
        }

         /*
          * 获取指定的构造方法,空参数的构造方法
          * getConstructor()
          */
         Constructor con = c.getConstructor();
        //运行空参数构造方法,Constructor类方法 newInstance()运行获取到的构造方法
         Object obj = con.newInstance();
         System.out.println(obj.toString());
    }

例：通过反射获取有参构造器

    @Test
    public void testReflect3() throws Exception{
        Class c = Class.forName(className);
        //获取带有,String和int参数的构造方法
        /*
         * Constructor<T> getConstructor(Class<?>... parameterTypes)
         * Class<?>... parameterTypes 传递要获取的构造方法的参数列表
         */
        Constructor con = c.getConstructor(String.class, int.class);
        Object obj = con.newInstance("张三", 15);
        System.out.println(obj.toString());
    }

通过反射获取有参构造方法并使用快捷方式
* a. 使用前提
被反射的类有空参的公共构造方法。（如果是同包，默认权限也可以）
* b. 使用方法
Class类的 public T newInstance() 方法
创建此 Class 对象所表示的类的一个新实例。

例：

    @Test
    public void testReflect4() throws Exception{
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }

通过反射获取私有构造方法并使用：
* a. 得到私有的构造方法
public Constructor getDeclaredConstructor(Class

    /*
     *  反射获取私有的构造方法运行
     *  不推荐,破坏了程序的封装性,安全性
     *  暴力反射
     */
    @Test
    public void testReflect5() throws Exception{
        Class c = Class.forName(className);
        Constructor con = c.getDeclaredConstructor(String.class);
        con.setAccessible(true);
        Object obj = con.newInstance("lisi");
        System.out.println(obj);
    }

3、反射获取成员变量并改值

A. 获取成员变量
- a. 得到公共的成员变量
  public Field getField(String name)
  返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
  public Field[] getFields()
  返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
- b. 得到所有的成员变量(包括私有的，如果要进行修改私有成员变量，要先进行public void setAccessible(boolean flag) 设置。)
  public Field getDeclaredField(String name)
  返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
  public Field[] getDeclaredFields()
  返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
B. 修改成员变量(Field)的值
- a. 修改公共的成员变量
  public void set(Object obj, Object value)
  将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
  obj指的是修改的是那个对象的这个成员变量值。

例：

    @Test
    public void testReflect6() throws Exception{
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        /*
         * 获取成员变量 Class类的方法 getFields() class文件中的所有公共的成员变量
         * 返回值是Field[]    Field类描述成员变量对象的类
         */
        Field[] fields = c.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        /*
         * 获取指定的成员变量 String name
         */
        Field f = c.getField("name");
        /*
         * Field类的方法 void set(Object obj, Object value) ,修改成员变量的值
         * Object obj 必须有对象的支持,  Object value 修改后的值
         */
        f.set(obj, "王尼玛");
        System.out.println(obj);
    }

4、反射获取成员方法并运行

a. 获取成员方法
- 得到公共的成员方法
  public Method getMethod(String name, Class

    @Test
    public void testReflect7() throws Exception{
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        /*
         * 获取class对象中的成员方法
         * Method[] getMethods()获取的是class文件中的所有公共成员方法,包括继承的
         * Method类是描述成员方法的对象
         */
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //获取指定的方法work运行
        Method work = c.getMethod("work");
        /*
         * 使用Method类中的方法,运行获取到的方法eat
         * Object invoke(Object obj, Object...o)
         */
        work.invoke(obj);
        //调用Class类的方法getMethod获取指定的方法sleep
        Method sleep = c.getMethod("sleep", String.class, int.class);
        sleep.invoke(obj, "霸霸",60);
    }

5、反射泛型擦除

a. 使用情况
例如：在泛型为String的集合里，添加Integer的数据
ArrayList list = new ArrayList();
list.add(100);
b. 能用泛型擦除的理论
伪泛型：在编译后的.class文件里面是没有泛型的。类型为Object。
用反射的方法绕过编译，得到Class文件对象，直接调用add方法。

注：没有使用价值

标签

#Java高级特性 #Java反射