[Java5新特性]反射

什么是反射机制

反射机制是Java 5版本提供的高级新特性，这种机制允许Java程序在运行状态中，对任意一个类都能知道该类的所有属性和方法；对任意一个对象，都能调用该对象的属性和方法。这种动态获取信息及动态调用对象的属性和方法的功能称之为Java的反射机制。

在我们编写Java类文件时，真正运行的是编译之后的“.class”文件。而“.class”文件在运行时，被加载到内存后，都是一个Class类的对象。我们可以通过Java 5提供的反射机制获取到该类的构造器、方法及成员变量等。

简单来说，Java的反射机制中提供了Class类、Constructor、Method及Field等，Class类就是类的元神，Constructor就是构造器的元神，Method就是方法的元神，Field就是成员变量的元神。

反射中的Class类

Class类是Java 5提供一个新类型，就叫做类类型。如何可以获取一个Class类型的对象呢？传统方式就是利用new Class()方式，但Java 5提供不同的方式。参看以下代码：

public class Demo {
    @Test
    public void demo() throws ClassNotFoundException {

        // 第一种方式:类名.class
        Class c1 = int.class;
        Class c2 = int[].class;

        // 第二种方式:对象.getClass()
        Class c3 = "hello".getClass();

        // 第三种方式:Class.forName("类全名")
        Class c4 = Class.forName("app.java.reflect.Demo");
    }
}

通过以上代码我们可以了解，获取Class实例的方式有三种：

• 类名.class，例如：Class c1 = Object.class;
• 对象.getClass()，例如：Class c2 = “Hello”.getClass();
• Class.forName(“类全名”)，例如：Class c1 = Class.forName(“app.java.reflect.Demo”);

获取到Class类实例之后，有什么具体用途呢？第一，我们可以通过Class类实例的getName()和getSimpleName()方法，获取到对应类的全类名或类名。

public class Demo {
    @Test
    public void demo() throws ClassNotFoundException {
        Class c1 = "hello".getClass();
        // java.lang.String
        System.out.println(c1.getName());

        Class c2 = int[].class;
        // [I:"["表示数组,"I"表示int类型
        System.out.println(c2.getName());
        // int[]
        System.out.println(c2.getSimpleName());
    }
}

第二，我们可以通过Class类实例的getSuperclass()方法，获取到对应类的完整继承链关系。

public class Demo {
    @Test
    public void demo() throws ClassNotFoundException {
        Class c = java.awt.Frame.class;
        while (c.getSuperclass() != null) {
            System.out.println(c.getSuperclass().getName());
            c = c.getSuperclass();
        }
    }
}

第三，我们可以通过反射机制来创建对象。

public class Demo {
    @Test
    public void demo() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        String className = "app.java.reflect.User";
        Class c = Class.forName(className);
        User user = (User) c.newInstance();
        user.setUsername("king");
        System.out.println(user.getUsername());
    }
}

class User{
    private String username;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    private String password;
}

反射中的Constructor

传统Java方式获取类的实例，基本都是通过构造器来实现，反射机制中的Class类同样具有构造器。那反射机制中Class类的构造器如何获得呢？我们来看以下代码：

public class Demo {

    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        // 获取c类型中所有public构造器
        Constructor[] constructors1 = c.getConstructors();
        // 获取c类型中所有构造器
        Constructor[] constructors2 = c.getDeclaredConstructors();

        System.out.println(constructors1.length);
        System.out.println(constructors2.length);

        // 获取没有参数的public构造器
        Constructor con1 = c.getConstructor();
        // 获取参数类型依次为String.class,String.class的public构造器
        Constructor con2 = c.getConstructor(String.class,String.class);
        // 获取参数类型为String.class的构造器
        Constructor con3 = c.getDeclaredConstructor(String.class);
    }
}

通过上面的代码，我们可以知道：在获取到Class类实例后，有四种方式可以获取到对应的构造器。

• getConstructors()方法：获取Class类所有的public构造器，其中包含没有参数和有参数的。
• getDeclaredConstructors()方法：获取Class类所有的构造器，其中包含由public、private和protected修饰符的。
• getConstructor()方法：获取具体的public修饰构造器，参数表示是否具有参数的构造器。
• getDeclaredConstructor()方法：获取具体的构造器，其中包含由public、private和protected修饰符的。

我们得到Class类型的构造器之后，又会有什么样的用途呢？第一，可以通过构造器来创建实例对象。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;
        Constructor<User> constructor = c.getConstructor(String.class,String.class);
        User user = constructor.newInstance("king","123");
        System.out.println(user);
    }
}

第二，我们可以构造器来打印指定类型的所有构造器，以及参数类型。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<String> c = String.class;
        Constructor[] constructors = c.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.print(constructor.getDeclaringClass().getSimpleName() + "(");
            Class[] classes = constructor.getParameterTypes();
            for (int i = 0; i < classes.length; i++) {
                System.out.print(classes[i].getSimpleName());
                if (i < classes.length - 1) {
                    System.out.print(", ");
                }
            }
            System.out.println(")");
        }
    }
}

反射中的Method

与Class类的构造器类似的就是方法，我们首先讨论如何获取方法。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        // 获取本类和父类中的所有public方法
        Method[] ms1 = c.getMethods();
        System.out.println(ms1.length);

        // 获取本类中所有方法
        Method[] ms2 = c.getDeclaredMethods();
        System.out.println(ms2.length);

        // 获取本类或父类中名称为setUsername，参数类型为String的public方法
        Method m1 = c.getMethod("setUsername", String.class);

        // 获取本类中声明的名称为toString的，没有参数的方法，它可以是任何访问级别，但它不能是父类中的方法
        Method m2 = c.getDeclaredMethod("toString");
    }
}

通过上面的代码，我们可以知道：在获取到Class类实例后，有四种方式可以获取到对应的方法。

• getMethods()方法：获取Class类及父类的所有public方法。
• getDeclaredMethods()方法：获取Class类的所有方法，其中包含由public、private修饰符的。
• getMethod()方法：获取Class类及父类中具体的public方法。
• getDeclaredMethod()方法：获取Class类中具体的方法，其中包含由public、private修饰符的。但不能是父类中的方法。

下面我们来看一个利用Class类实例方法的练习。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        Method method = c.getMethod("setUsername", String.class);

        Object object = c.newInstance();

        method.invoke(object, "king");

        System.out.println(object);
    }
}

反射中的Field

与Class类的构造器和方法类似的就是成员变量，我们首先讨论如何获取成员变量。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        // 获取本类和父类中的所有public成员变量
        Field[] fields1 = c.getFields();
        System.out.println(fields1.length);

        // 获取本类中所有成员变量
        Field[] fields2 = c.getDeclaredFields();
        System.out.println(fields2.length);

        // 获取本类或父类中名称为password，参数类型为String的public成员变量
        Field field1 = c.getField("password");

        // 获取本类中名称为password的成员变量，但它不能是父类中的成员变量
        Field field2 = c.getDeclaredField("password");
    }
}

通过上面的代码，我们可以知道：在获取到Class类实例后，有四种方式可以获取到对应的成员变量。

• getFields()方法：获取Class类及父类的所有public成员变量。
• getDeclaredFields()方法：获取Class类的所有成员变量，其中包含由public、private修饰符的。
• getField()方法：获取Class类及父类的具体成员变量。
• getDeclaredField()方法：获取Class类的具体成员变量，其中包含由public、private修饰符的。但不能是父类中的方法。

获取到Class类的成员变量之后，我们可以进行设置和获取操作。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        Field field = c.getField("password");

        Object object = c.newInstance();

        field.set(object, "123");
        System.out.println(field.get(object));
    }
}

需要注意的是这里只能设置和获取修饰符为public的成员变量，不能操作修饰符为private的成员变量。

AccessibleObject

AccessibleObject类是Constructor、Method和Field三个类的父类。AccessibleObject类的常用方法有以下几种：

• isAccessible()方法：判断当前成员是否可访问。
• setAccessible()方法：设置当前成员是否可访问。

当Class类中的构造器、方法和成员变量是私有的时候，如果我们想反射操作的话，就必须先调用setAccessible(true)方法。

public class Demo {
    @Test
    public void demo() throws Exception{
        Class<User> c = User.class;

        Field field = c.getDeclaredField("username");

        Object object = c.newInstance();

        field.setAccessible(true);

        field.set(object, "king");

        System.out.println(field.get(object));
    }
}

---

转载说明：请注明作者及原文链接，谢谢！