《Thinking in Java 第4版》（十）——类型信息

Java中的每一个类都对应着一个Class对象（java.lang.Class）。通过这个Class对象你可以在运行时得到很多类中的有用的信息。用Class.forName来得到一个Class对象。

try {
    Class c = Class.forName("MyClass");
    String name = c.getName(); // "MyPackge.MyClass"
    name = c.getSimpleName(); // "MyClass"
    name = c.getCanonicalName(); // "MyPackge.MyClass"
    Class superClass = c.getSuper();
    if (superClass != null) // Object's super class is null
        superClass.newInstance();
    boolean b = c.isInterface();
    for(java.lang.Class face: c.getInterfaces())
        name = face.getName();
} catch (ClassNotFoundException) {}

除了Class.forName，还可以直接用MyClass.class来得到一个Class对象。这种方式不会抛出异常。所有的类，包括基本类型，都可以使用“.class”。比如int.class。基本类型的包装类有TYPE成员，比如Integer.TYPE与int.class是一样的。

不像C++在程序启动时就把所有的静态数据与执行代码载入到内存中，java根据需要在运行时把字节码载入到内存，它分三个步骤：1、加载：类加载器查找到字节码（.class文件）并根据这些字节码创建一个Class对象；2、链接：验证类中的字节码，为静态域分配存储空间，需要的话同时解析这个类其它类的所有引用；3、初始化：当类的静态方法（构造器是特殊的静态方法）或者非常数静态域（即不是编译器常量）被首次引用时，执行静态初始化块和初始化静态数据。

Class类是支持范型的：

Class<Integer> c = int.class;

Class范型的作用是可以得到编译器的支持，比如类型检查：

Class<Interger> c = int.class;

除了类型检查，Class范型的new Instance会返回相应类型的对象，不仅仅是个简单的Object：

Class c = int.class;
Class<Integer> cc = int.class;
Object o = c.newInstance();
Integer i = cc.newInstance();

这种范型强制性太大，如果希望一个Class范型的引用接受别的Class类型的对象，可以使用通配符：

Class<?> c = int.class;
c = double.class;

Class其实与普通的Class类是一样的，只不过显式声明你确实需要一个接受任何类型的Class对象，而不是忘了加范型参数。

如果你想让一个Class范型类既能接受int.class，又能接受double.class，但是不想接受其它非数值的类型，可以这样：

Class<? extends Number> c = int.class;
c = double.class;
Number n = c.newInstance();

?extends通配符可以让编译器确保接受的类型是某个类型的子类。另一个通配符?super可以得保证接受的类型是某个类的超类：

class Base {}
class Derived extends Base {}
// Class c = Derived.class.getSuperclass(); // won't compile
Class<? super Derived> c = Derived.class.getSuperclass();
Object o = c.newInstance();

看到上例的Class不能接受子类的getSuperClass的返回值，还是挺奇怪的，毕竟Base是Derived的基类是在编译时就确定的。不过既然编译器规定Class到Class的转换，那也只能遵从了。

Class范型提供一个cast方法：

Base b = new Derived;
Class<Derived> c = Derived.class;
Derived d = c.cast(b);

这样的cast其实与Derived d = (Derived)b;是完全等价的，所以这样的cast基本不怎么用。如果被转换的类不能被cast到目标类型的话，会抛出一个ClassCastException异常。（C++里cast是不会使用RTTI的。）另一个基本没用的方法是Class.asSubClass：

Class<? extends Base> c = Derived.class.asSubclass(Base.class);
Derived d = (Derived)c.newInstance();

另一个在运行时得到类型信息的方法是关键字instanceof它与Class.isInstance是等价的：

Base o = new Derived();
boolean b = o instanceof Derived; // true
b = Derived.class.isInstance(o);

以上介绍的都是java的RTTI机制。Java还有一套反射机制。RTTI能够维护的类型都是编译时已知的类型，而反射可以使用一些在编译时完全不可知的类型。比如在进行一个远程调用时，类信息是通过网络传输过来的，编译器在编译时并不知道这个类的存在。下面演示如何使用反射：

import java.lang.reflect.*;

class SomeClass {
public SomeClass() {}
public int SomeMethod(double d, char c) { return 2; }
    public int a;
}

public class ReflectTest {
    public static void main(String[] args) {
        Class c = Class.forName("SomeClass");
        for (Constructor<?> constructor: c.getConstructors())
            System.out.println(constructor);
        for (Method method: c.getMethods())
            System.out.println(method);
        for (Field field: c.getFields())
            System.out.println(field);

        SomeClass sc = new SomeClass();
        Method method = c.getMethod("SomeMethod", double.class, char.class);
        Integer returnedValue = (Integer)method.invoke(sc, 3, '4');
        Field field = c.getField("a");
        int value = field.getInt(sc);
        System.out.println(value);
    }
}

其实反射和RTTI并没有什么本质的区别，因为java的类都是在运行是加载并解析的，而且两者通过Class对象来获取类型信息。不同的地方就是RTTI可以直接使用方法名来调用一个方法，而不必用字符串去执行一个方法。

设计模式里有个"代理模式"（点击链接进入博客：设计模式 ——　《Head First》）。代理模式里会定义一个接口，真正工作的类和代理类都会实现这个接口，但用户只会看到代理类，而不知道真正工作的类。这个模式的好处就是可以隐藏实现细节，经常改动的地方对用户是不可见的。Java里提供了一个自动生成代理类的机制，主要使用java.lang.reflect包里的Proxy类和InvocationHandler接口：

import java.lang.reflect.*;

interface MyInterface {
    void doSomething();
}

class RealWorker implements MyInterface {
    public void doSomething() { System.out.println("RealWorker"); }
}

class MyHandler implements InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return method.invoke(worker, args);
    }
    private MyInterface worker = new RealWorker();
}

public class ProxyTest {
    public static void main(String[] args) {
        MyInterface myProxy = (MyInterface)Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class[] {MyInterface.class}, new MyHandler());
        // call proxy's methods
        myProxy.doSomething();
    }
}

可以看到我们只定义了一个接口和实现这个接口的类，但没有直接定义一个代理类，而是通过实现InvocationHandler和使用Proxy.newProxyInstance让编译器自动生成一个Proxy类。

通过反射机制可以做一些很违反规定的事情。你可以使用一个某个包里不对外开放的类，以及它的私有方法：

///////////// HiddenClass.java ///////////////
package hidden;

class HiddenClass {
    private void invisible() { System.out.println("invisible"); }
}

///////// HiddenClassTest.java ///////////////////
import java.lang.reflect.*;
import hidden.*;

public class HiddenClassTest {
    public static void main(String[] args) {
        Class c = Class.forName("hidden.HiddenClass");

        // Object obj = c.newInstance(); // IllegalAcces***cetion
        Constructor constructor = c.getDeclaredConstructor();
        constructor.setAccessible(true);
        Object obj = constructor.newInstance(); // new HiddenClass()

        Method method = c.getDeclaredMethod("invisible");
        method.setAccessible(true);
        method.invoke(obj); // call HiddenClass.invisible()
    }
}

当然这样的做法是很不值得提倡的。除了普通的类，同样可以用Class.forName("OuterClass$InnerClass")的方式来访问内部类。访问匿名类则用Class.forName("OuterClass$1")的方式。有一点值得注意的是，内部类和匿名类的构造函数的第一个参数是外部类的引用，所以getDeclaredConstructor方法的以外部类的类型作为第一个参数。这里就不再列出代码了。