java的RTTI和反射机制

Posted 2020-06-20 Harley_Quinn

RTTI，即Run-Time Type Identification，运行时类型识别。它假定我们在编译时已经知道了所有的类型。那么在运行时就能够自动识别每个类型。

很多时候需要进行向上转型，比如Base类派生出Derived类，但是现有的方法只需要将Base对象作为参数，实际传入的则是其派生类的引用。那么RTTI就在此时起到了作用，比如通过RTTI能识别出Derive类是Base的派生类，这样就能够向上转型为Derived。类似的，在用接口作为参数时，向上转型更为常用，RTTI此时能够判断是否可以进行向上转型。

而这些类型信息是通过Class对象（java.lang.Class）的特殊对象完成的，它包含跟类相关的信息。每当编写并编译一个类时就会产生一个.class文件，保存着Class对象，运行这个程序的Java虚拟机（JVM）将使用被称为类加载器（Class Loader）的子系统。而类加载器并非在程序运行之前就加载所有的Class对象，如果尚未加载，默认的类加载器就会根据类名查找.class文件（例如，某个附加类加载器可能会在数据库中查找字节码），在这个类的字节码被加载时接受验证，以确保没有被破坏并且不包含不良Java代码。这也是Java中的类型安全机制之一。一旦某个类的Class对象被载入内存，就可以创建该类的所有对象。

package typeinfo;

class Base {
    static { System.out.println("加载Base类"); }
}

class Derived extends Base { 
    static { System.out.println("加载Derived类");}
}

public class Test {
    static void printerInfo(Class c) {
        System.out.println("类名: " + c.getName() +
            "是否接口? [" + c.isInterface() + "]");
    }
    public static void main(String[] args) {
        Class c = null;
        try {
            c = Class.forName("typeinfo.Derived");
        } catch (ClassNotFoundException e) {
            System.out.println("找不到Base类");
            System.exit(1);
        }
        printerInfo(c);
        
        Class up = c.getSuperclass(); // 取得c对象的基类
        Object obj = null;
        try {
            obj = up.newInstance();
        } catch (InstantiationException e) {
            System.out.println("不能实例化");
            System.exit(1);
        } catch (IllegalAccessException e) {
            System.out.println("不能访问");
            System.exit(1);
        }
        printerInfo(obj.getClass());
    } /* 输出:
    加载Base类
    加载Derived类
    类名: typeinfo.Derived是否接口? [false]
    类名: typeinfo.Base是否接口? [false]
    */
}

上述代码中，forName方法是静态方法，参数是类名，用来查找是否存在该类，如果找到则返回一个Class引用，否则会抛出ClassNotFoundException异常。

如果类不是在默认文件夹下，而是在某个包下，前面的包名需要带上，比如这里的typeinfo.Derived。

可以通过getSuperclass方法来返回基类对应的Class对象。使用newInstance方法可以按默认构造创建一个实例对象，在不能实例化和不能访问时分别抛出。会抛出InstantiationException和IllegalAccessException异常。

Java还提供了一种方法来生成对Class对象的引用，即类字面常量。对上述程序来说，up等价于Base.class。

对于基本数据类型的包装类来说，char.class等价于Character.TYPE，int.class等价于Integer.TYPE。其余的ab.class等价于Ab.TYPE。（比如void.class等价于Void.TYP）。另外，Java SE5开始int.class和Integer.class也是一回事。

 

泛化的Class引用，见下面代码

        Class intClass = int.class;
        Class<Integer> genericIntClass = int.class;
        genericIntClass = Integer.class;  // 等价
        intClass = double.class;  // ok
        // genericIntClass = double.class; // Illegal!

Class<Integer>对象的引用指定了Integer对象，所以不能将引用指向double.class。为了放松限制可以使用通配符?，即Class<?>，效果跟Class是一样的，但是代码更为优雅，使用Class<?>表示你并非是碰巧或疏忽才使用一个非具体的类引用。同时，可以限制继承的类，示例如下

class Base {}
class Derived extends Base {}
class Base2 {}

public class Test {
    public static void main(String[] args) {
        Class<? extends Base> cc = Derived.class; // ok
        // cc = Base2.class;  // Illegal
    } 
}

向Class引用添加泛型语法的原因仅仅是为了提供编译期类型检查，以便在编译时就能发现类型错误。

总结下来，我们已知的RTTI形式包括：

1、传统的类型转换，由RTTI保证类型转换的正确性，如果执行一个错误的类型转换，就会抛出ClassCastException异常；

2、代表对象的类型的Class对象，通过查询Class对象（即调用Class类的方法）可以获取运行时所需的信息。

在C++中经典的类型转换并不使用RTTI，这点具体见C++的RTTI部分。（说句题外话，以前学C++时看到RTTI这章只是随便扫了眼，现在才记起来dynamic_cast什么的都是为了类型安全而特地添加的，C++在安全方面可以提供选择性，就像Java的StringBuilder和StringBuffer，安全和效率不可兼得？而Java在类型安全上则更为强制，就像表达式x = 1不能被隐式转型为boolean类型）。

而Java中RTTI还有第3种形式，就是关键字instanceof，返回一个布尔值，告诉对象是不是某个特定类型的示例，见下列代码。

class Base {}
class Derived extends Base {}

public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        System.out.println(derived instanceof Base); // 输出true
    } 
}

利用instanceof可以判断某些类型，比如基类Shape派生出各种类（Circle、Rectangle等），现在某方法要为所有Circle上色，而输入参数时一堆Shape对象，此时就可以用instandof判断该Shape对象是不是Circle对象。

 

参考：《Java编程思想》第四版，更多细节见书上第14章