Java 类型信息详解和反射机制

本文部分摘自 On Java 8

RTTI

RTTI（RunTime Type Information）运行时类型信息，能够在程序运行时发现和使用类型信息，把我们从只能在编译期知晓类型信息并操作的局限中解脱出来

传统的多态机制正是 RTTI 的基本使用：假设有一个基类 Shape 和它的三个子类 Circle、Square、Triangle，现在要把 Circle、Square、Triangle 对象放入 List<Shape> 中，在运行时，先把放入其中的所有对象都当作 Object 对象来处理，再自动将类型转换为 Shape。所有类型转换的正确性检查都是在运行时进行的，这也正是 RTTI 的含义所在：在运行时，识别一个对象的类型

但这样的类型转换并不彻底，Object 只是被转型为 Shape，而不是更具体的 Circle、Square、Triangle，如果我们希望得到更具体的类型呢？比如说我们现在需要旋转所有图形，但是想跳过圆形（圆形旋转没有意义），这时可以使用 RTTI 查询某个 Shape 引用所指向对象的确切类型，然后选择进行合适的处理

Class 对象

众所周知，每当我们编写并编译了一个新类，就会产生一个 Class 对象，它包含了与类有关的信息。我们可以使用 Class 对象来实现 RTTI，一旦某个类的 Class 对象被载入内存，它就可以用来创建这个类的所有对象

Class 对象都属于 Class 类型，既然它也是对象，那我们就可以获取和操控它的引用。forName() 是 Class 类的一个静态方法，我们可以使用 forName() 根据目标类的全限定名（包含包名）得到该类的 Class 对象。使用 forName() 会有一个副作用，那就是如果这个类没有被加载就会加载它，而在加载的过程中，Gum 类的 static 初始块会被执行。当 Class.forName() 找不到要加载的类，就会抛出异常 ClassNotFoundException

Class gumClass = Class.forName("Gum");

使用 Class.forName() 你不需要先持有这个类型的对象，但如果你已经拥有了目标类的对象，那就可以通过调用 getClass() 方法来获取 Class 引用，这个方法来自根类 Object，它将返回表示该对象实际类型的 Class 对象的引用

Gum gum = new Gum();
Class gumClass = gum.getClass();

另外，你还可以调用 getSuperclass() 方法来得到父类的 class 对象，再用父类的 Class 对象调用该方法，重复多次，你就可以得到一个完整的类继承结构

Class 对象的 newInstance() 方法可以让你在不知道一个的确切类型的时候创建这个类的对象，使用 newInstance() 来创建的类，必须带有无参数的构造器

Object obj = gumClass.newInstance();

当然，由于得到的是 Object 的引用，目前你只能给它发送 Object 对象能接受的调用。如果你想请求具体对象才有的调用，你就得先获取该对象的更多类型信息，并执行转型

Java 还提供了另一种生成类对象的引用：类字面常量，这样做不仅更简单，而且更安全，因为它在编译时就会收到检查（不用放在 try 语句块中），而且根除了对 forName() 方法的调用，效率更高

Class gumClass = Gum.class; 

类字面常量不仅可以用于普通类，也可以用于接口、数组以及基本数据类型。对于基本数据类型的包装类，还有一个标准字段 Type，Type 字段是一个引用，指向对应基本数据类型的 Class 对象，例如 int.class 就等价于 Integer.TYPE。还有一点值得注意的是：使用 .class 语法来获得对类对象的引用不会触发初始化

到这里我们都知道了，Class 引用总是指向某个 Class 对象，而 Class 对象可以用于产生类的实例。不过自从 Java 引入泛型以后，我们就可以使用泛型对 Class 引用所指向的 Class 对象的类型进行限定，让它的类型变得更具体些

Class intClass = int.class;
Class<Integer> genericIntClass = int.class;
intClass = genericIntClass;	// 同一个东西
// genericIntClass = double.class	非法

好了，既然拿到了 Class 对象，那我们就可以这个类的类型信息，常用的方法如下：

类型转换检测

到目前为止，我们已知的 RTTI 类型包括：

1. 传统的类型转换，如多态
2. 代表对象类型的 Class 对象

RTTI 在 Java 中还有第三种形式，那就是关键字 instanceof，它返回一个布尔值，告诉我们对象是不是某个特定类型的实例，可以用提问的方式使用它

if(x instanceof Dog) {
    ((Dog)x).bark();
}

Java 还提供了 Class.isInstance() 方法动态检测对象类型，例如

0 instance of String // 编译报错
String.class.isInstance(0)	// 可以通过编译

反射

如果你不知道对象的确切类型，RTTI 会告诉你，但是有一个限制：必须在编译时知道类型，才能使用 RTTI 检测它。换句话说，编译器必须知道你使用的所有类

看上去这并不是什么特别大的限制，但假设你引用了一个不在程序空间中的对象，比如你从磁盘文件或网络连接中获得大量的字节，并被告知这些字节代表一个类，那该怎么办呢？

类 Class 支持反射的概念，java.lang.reflect 库中支持类 Field、Method、Constructor（每一个都实现了 Member 接口），这些类型的对象由 JVM 运行时创建，以表示未知类中的对应成员。通常我们不会直接使用反射，但反射可以用来支持其他 Java 特性，例如对象序列化等

Field 代表类的成员变量（成员变量也称为类的属性），Class 类中定义了如下方法用来获取 Field 对象

Field 类定义了如下方法设置成员变量的信息

Method 代表类的方法，Class 类中定义了如下方法用来获取 Method 对象

Method 类定义了如下方法对方法进行调用

Constructor 代表类的构造器，Class 类中定义了如下方法用来获取 Constructor 对象

Constructor 代表类的构造方法

除了成员变量、方法和构造器以外，反射还能获取其他更多的信息，例如注解等，具体可查阅 Java API

反射的强大威力大家已经看到了，通过反射我们甚至可以获取到一些“本不应该获取”的信息，例如程序员为了降低耦合，往往会使用接口来隔离组件，但反射却可以轻易破解

public interface A {
    void f();
}


class B implements A {
    public void f() {}
    public void g() {}
}

public class InterfaceViolation {
    public static void main(String[] args) {
        A a = new B();
        a.f();
        // a.g(); // 编译错误
        if (a instanceof B) {
            B b = (B) a;
            b.g();
        }
    }
}

通过使用 RTTI，我们发现 a 是用 B 实现的，只要将其转型为 B，我们就可以调用不在 A 中的方法。如果你不希望客户端开发者这样做，那该如何解决呢？一种解决方案是直接声明为实际类型，另一种则是让实现类只具有包访问权限，这样包外部的客户端就看不到实现类了

除了这个以外，通过反射可以获得所有成员信息，包括 private 的，通常这种违反访问权限的操作并不是十恶不赦的，也许还可以帮助你解决某些特定类型的问题

动态代理

代理是基本的设计模式之一，一个对象封装真实对象，代替真实对象提供其他不同的操作，这些操作通常涉及到与真实对象的通信，因此代理通常充当中间对象。下面是一个简单的静态代理的示例：

interface Interface {    
    void doSomething();
}

class RealObject implements Interface {
    @Override
    public void doSomething() {
        System.out.println("doSomething");
    }
}

class SimpleProxy implements Interface {
    private Interface proxied;

    SimpleProxy(Interface proxied) {
        this.proxied = proxied;
    }

    @Override
    public void doSomething() {
        System.out.println("SimpleProxy doSomething");
        proxied.doSomething();
    }
}

class SimpleProxyDemo {
    public static void consumer(Interface iface) {
        iface.doSomething();
    }

    public static void main(String[] args) {
        consumer(new RealObject());
        consumer(new SimpleProxy(new RealObject()));
    }
}

当你希望将额外的操作与真实对象做分离时，代理可能会有所帮助，而 Java 的动态代理更进一步，不仅动态创建代理对象，而且可以动态地处理对代理方法的调用。在动态代理上进行的所有调用都会重定向到一个调用处理程序，该程序负责发现调用的内容并决定如何处理，下面是一个简单示例：

class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(proxied, args);
    }
}

class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[]{Interface.class},
                new DynamicProxyHandler(real));
        consumer(proxy);
    }
}

通过调用静态方法 Proxy.newProxyInstance() 来创建动态代理，该方法需要三个参数：类加载器、希望代理实现的接口列表、以及接口 InvocationHandler 的一个实现。InvocationHandler 正是我们所说的调用处理程序，动态代理的所有调用会被重定向到调用处理程序，因此通常为调用处理程序的构造函数提供一个真实对象的引用，以便执行中间操作后可以转发请求