java反射机制

最新推荐文章于 2024-09-14 18:46:05 发布

骑鱼的少年

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量347

点赞数

分类专栏： java 随记待学文章标签： java java反射机制

java 随记待学专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.Java反射机制的定义和作用

java反射机制定义：Java反射机制是在运行状态时，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能够调用这个对象的所有属性和方法。

我们不禁会想，得到这些属性和方法并且去改变它们有什么用？觉得反射机制仿佛很遥远，但是作为一个全职程序员，除了假期和双休日，你几乎每天都在和反射机制打交道，无论你使用的Eclipse系列的IDE（集成开发环境），还是使用的目前较为流行的IntelliJ IDEA，又或者是NetBeans，在你输入一个对象的名称，按下”.”时，总会弹出这个对象所拥有的所有方法列表供选择。这个功能就是反射机制实现的，反射机制得到了这个对象的方法和属性。

2.Java反射机制的类库支持及简介

Class类和java.lang.reflect类库一起构成了对Java反射机制的支持。其中最常使用到的类Constructor，Field，Method，而这三个类都继承了一个接口java.lang.reflect.Member。下面列举介绍一下java.lang.reflect类库中的类：

AccessibleObject：Field，Method，和Constructor对象的基类。提供了将反射的对象标记为在使用时取消默认Java语言访问控制检查的能力。
Array：提供了动态创建和访问Java数组的方法。
Constructor：提供关于类的单个构造方法的信息以及对它的访问权限。、
Method：提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。
Modifier：类提供了 static 方法和常量，对类和成员访问修饰符进行解码。修饰符集被表示为整数，用不同的位位置 (bit position) 表示不同的修饰符。该类的字段均是int类型的变量。
Proxy：提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
ReflectPermission：反射操作的 Permission 类。ReflectPermission 是一种指定权限，没有动作。当前定义的唯一名称是 suppressAccessChecks，它允许取消由反射对象在其使用点上执行的标准 Java 语言访问检查 - 对于 public、default（包）访问、protected、private 成员。

当要使用反射机制去探查一个类的内部时，还可以调用getFields()，getMethods()和getConstructors()等很便利的方法。对于反射机制，和RTTI的区别就在于，RTTI是在编译时打开和检查.class文件，而反射机制是在运行时打开和检查.class文件。

3.得到Class类对象有三种方法

Class.forName()
Object.getClass()
类字面常量xx.class

解释一下这三种方法，

第一种方法是Class类自带的方法，

第二种方法是所有的对象都能够使用的方法，因为getClass()方法是Object类的方法，所有的类都继承了Object，因此所有类的对象也都具有getClass()方法。

第三种方法是类字面常量。Thinking in Java中建议使用类字面常量来生成对Class对象的引用，这样做即简单又安全，因为在编译时就会受到检查，因此不需要置于try语句块中，并且它根除了对forName()方法的调用，所以也更高效。可以想象一下JDBC的语法，在加载驱动的时候，使用的就是forName()方法，因此即使单独这一句程序，也要使用try语句块。

类字面常量使得创建Class对象的引用时不会自动地初始化该对象，而是按照之前提到的加载，链接，初始化三个步骤，这三个步骤是个懒加载的过程，不使用的时候就不加载，这种机制是C/C++无法复制模拟的。

4.Java反射机制demo（一）——实例化Class对象，通过对象获得包名和类型

使用Java中的本地类作为实验对象，避免自定义的类带来的一些不便。

public static void main(String[] args) { 
    try {
      Class c1 = Class.forName("java.lang.Integer");
      System.out.println(c1.getName());
    } catch (ClassNotFoundException e) {
      System.out.println("forName出错");
}
  Integer i = 1;
  Class c2 = i.getClass();
  System.out.println(c2.getName());
  Class c3 = Integer.class;
  System.out.println(c3.getName());
}

上面这段程序中，最后的输出结果为：

java.lang.Integer
java.lang.Integer 
java.lang.Integer

如果使用基本类型int，只有最后一种方法才好用，因为forName的方式如果只是Integer，而不是java.lang.Integer就会抛出异常，这个方法不会自动的去搜索，只会按照给出的路径严格寻找，寻找不到就抛出ClassNotFoundException。第二种方法也非常方便，但是基本类型就无能为力了，因为java中的8种基本类型不是Object的子类，而第三种方法就会简洁而且高效。

5.Java反射机制demo（二）—通过Class实例化任意类的对象

上一章节中，实例化了Class类对象的实例，这个部分的demo展示了如何使用Class对象的实例去获得其他类的对象的实例。

任意一个类，UserInfo，

package com.aaron.reflect;

public class UserInfo{
    private int userId;
    private String name;
    private int age;

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "UserInfo [userId=" + userId + ", name=" + name + ", age=" + age + "]";
    }

}

使用newInstance方法，通过调用默认的无参构造来实例化一个UserInfo的对象

package com.aaron.reflect;

public class Demo1 {
    public static void main(String[] args) {
        Class<?> c = UserInfo.class;//获得Class类实例
        UserInfo userInfo = null;

        try {
            userInfo = (UserInfo) c.newInstance();//通过Class类的实例获得UserInfo的实例
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        userInfo.setUserId(1);
        userInfo.setName("Squee,Spleen and Goblin");
        userInfo.setAge(10);

        System.out.println(userInfo);
    }
}

如果了解Java虚拟机，应该知道，一个对象在new之前，堆里是不会分配内存的。因此这个UserInfo的实例是通过Class的实例得到的。

运行结果：

UserInfo [userId=1, name=Squee,Spleen and Goblin, age=10]

注意事项：
newInstance()调用的是无参的空构造，如果只有参数的构造函数：如下：

private int userId;
private String name;
private int age;

public UserInfo(int userId, String name, int age) {
    super();
    this.userId = userId;
    this.name = name;
    this.age = age;
}

运行Demo，抛出异常：

java.lang.InstantiationException: com.aaron.reflect.UserInfo
at java.lang.Class.newInstance(Class.java:359)
at com.aaron.reflect.Demo1.main(Demo1.java:9)
Exception in thread “main” java.lang.NullPointerException
at com.aaron.reflect.Demo1.main(Demo1.java:16

此时，要定义一个空的构造函数（显式地声明一个空的构造函数）。　
所以，显式声明空的构造函数有时候也是一种很好的习惯。当你要使用反射时，一定不要忘记空的构造。

6.Java反射机制demo（三）—获取类中的构造函数

1，获取类中所有的构造函数
如下面的代码中所示，这个类中显式的构造函数有五个。
空构造：

public UserInfo()

带参构造有四个：

public UserInfo(int userId)
private UserInfo(String name)
protected UserInfo(int userId, String name)
public UserInfo(int userId, String name, int age)

注意他们的访问修饰符。

package com.aaron.reflect;

public class UserInfo{
    private int userId;
    private String name;
    private int age;

    public UserInfo(){}

    public UserInfo(int userId){
    　　　　this.userId = userId;
    }
　　　　　private UserInfo(String name){
　　　　　　　　　this.name = name;
　　　　　}

    public UserInfo(int userId, String name, int age) {
        super();
        this.userId = userId;
        this.name = name;
        this.age = age;
    }

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "UserInfo [userId=" + userId + ", name=" + name + ", age=" + age + "]";
    }

}

我们可以使用Class类中的`Constuctor<?>[] getConstructors()方法，来获得这个类的构造函数。

JDK API文档里，对这个方法的描述如下：

返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。如果该类没有公共构造方法，或者该类是一个数组类，或者该类反映一个基本类型或 void，则返回一个长度为 0 的数组。注意，此方法返回 Constructor<T> 对象的数组（即取自此类构造方法的数组）时，此方法的返回类型是 Constructor<?>[]，不是预期的 Constructor<T>[]。此少量信息的返回类型是必需的，因为从此方法返回之后，该数组可能被修改以保存不同类的 Constructor 对象，而这将违反 Constructor[] 的类型保证。

总之，返回了表示此类公共构造方法的Constructor对象数组。注意，这里是公共构造方法。

测试类的代码如下：
Constuctor<?>[] getConstructors()

package com.aaron.reflect;

import java.lang.reflect.Constructor;

public class Demo2 {
    public static void main(String[] args) {
        Class<?> c = UserInfo.class;//获取Class对象

        Constructor<?> cons[] = c.getConstructors();//获取构造函数的数组
        //打印
        for (Constructor<?> constructor : cons) {
            System.out.println(constructor);
        }
    }
}

运行结果如下：

public com.aaron.reflect.UserInfo()
public com.aaron.reflect.UserInfo(int,java.lang.String,int)
public com.aaron.reflect.UserInfo(int)

运行的结果打印出了所有显式声明的，而且是公共的构造函数。

但是，这个顺序和我们类里的定义顺序是不一样的，因此，从这个方法精准地定位一个构造函数是不可取的。真的乱序的吗？API里没有提到。但是，另外一个方法的文档中提到了。这个方法是

Constuctor<?>[] getDeclaredConstructors()
这个方法返回Constructor对象的一个数组，这些对象包含了Class对象所表示的类中的所有构造方法。它们分别是公共，保护，默认（包），和私有构造。

返回数组中的元素没有排序，也没有任何特定的顺序。

如果该类存在一个默认构造方法，则它包含在返回的数组中。如果此Class对象表示一个接口，一个基本类型，一个数组类或者void，则这个方法返回一个长度为0的数组。

测试类：

package com.aaron.reflect;

import java.lang.reflect.Constructor;

public class Demo2 {
    public static void main(String[] args) {
        Class<?> c = UserInfo.class;//获取Class对象

        Constructor<?> cons[] = c.getDeclaredConstructors();
        //打印
        for (Constructor<?> constructor : cons) {
            System.out.println(constructor);
        }
    }
}

运行结果如下：

public com.aaron.reflect.UserInfo()
public com.aaron.reflect.UserInfo(int,java.lang.String,int)
public com.aaron.reflect.UserInfo(int)
private com.aaron.reflect.UserInfo(java.lang.String)
protected com.aaron.reflect.UserInfo(int,java.lang.String)

2，调用构造方法生成实例

Constructor<T> getConstructor(Class<?>... parameterTypes)

package com.aaron.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {
    public static void main(String[] args) {
        Class<?> c = UserInfo.class;//获取Class对象
        try {
            Constructor<?> constructor = c.getConstructor(int.class);//只有使用类字面常量才能够获取基本类型的Class对象
            UserInfo userInfo = (UserInfo) constructor.newInstance(1);//构造实例
            System.out.println(userInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}