Java RTTI机制与反射机制

1.1 什么是RTTI？

维基百科的定义：In computer programming, RTTI (Run-Time Type Information, or Run-Time Type Identification) refers to a C++ mechanism that exposes information about an object's data type at runtime. Run-time type information can apply to simple data types, such as integers and characters, or to generic types. This is a C++ specialization of a more general concept called type introspection. 

运行时类型信息使得你可以在程序运行时发现和使用类型信息。Runtime type information (RTTI) allows you to discover and use type information while a program is running.

简而言之：当有一个指向基类对象的引用时，使用RTTI可以查询这个引用所引用的对象的确切类型。

在java中可以通过两种方式让我们在运行时识别对象和类的信息：

（1）传统的RTTI：它假设我们在编译时已经知道了所有的类型；

（2）反射机制：它允许我们在运行时发现和使用类的信息。

1.2 为什么需要RTTI？

通常需要知道某个引用类型的变量（为了利用多态的优势，一般是泛化引用，即指向父类的引用变量）所引用的对象的具体类型， 以便根据具体的类型再做具体的不同的操作。使用RTTI可以帮助我们确定泛化引用所引用对象的确切类型。

一般是如下流程：判断引用变量的具体类型 → 转换为具体的类型 → 执行特殊类型相关的操作。

1.3 Java中类型信息在运行时是如何表示的？

这是由Class对象表示的，它包含了与类有关的信息。Java使用Class对象来执行其RTTI，即使你正在执行的是类似转换这样的操作。（Java performs its RTTI using the Class object, even if you’re doing something like a cast.）

 

2.1 传统的RTTI

严格的说，反射也是一种形式的RTTI，不过，一般的文档资料中把RTTI和反射分开，因为一般的，大家认为RTTI指的是传统的RTTI。 

Java中使用RTTI的3种形式（java中已知的RTTI形式）

（1）传统的类型转换

比如“（Type）”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，会抛出ClassCastException。在Java中，所有的类型转换都是在运行才进行正确性检查的。所以在运行时需要识别一个对象的类型。注意，C++中类型转换是不会使用RTTI的。

传统的RTTI使用转型或instanceof形式（即以instanceof的形式或isInstance()的形式）实现，但都需要指定要转型的类型，比如：

    public void rtti(Object obj){
        Orange orange = (Orange)obj;    //其中的obj虽然是被转型了，但在编译期，就需要知道要转成的类型Orange，也就是需要Orange的.class文件
        //Class clazz = Class.forName("rtti.Orange");    //相对的，反射完全在运行时在通过Class类来确定类型，不需要提前加载Orange的.class文件。
    }

（2）代表对象类型的Class对象

通过查询Class对象可以获取运行时所需的信息。（用了Class对象，不代表就是反射，如果只是用Class对象cast成指定的类，那就还是传统的RTTI）。其实反射和RTTI并没有什么本质的区别，因为java的类都是在运行是加载并解析的，而且两者通过Class对象来获取类型信息。只是RTTI能够维护的类型都是编译时已知的类型，而反射可以使用一些在编译时完全不可知的类型。

        Class clazz = Orange.class;    //获取Class对象,Orange这个类必须是编译时可知的
        System.out.println(clazz.getName());    //利用class对应获取各种类型信息
        System.out.println(clazz.getTypeName());
        System.out.println(clazz.getSuperclass());
        System.out.println(clazz.isInterface());

（3）instanceof或Class.isInstance()

传统的RTTI使用转型或instanceof形式（即以instanceof的形式或isInstance()的形式）实现，但都需要指定要转型的类型，比如：

        if(x instanceof Apple){    //Apple这个类必须是编译时可知的，编译器在编译时会去打开和检查Apple对应的.class文件
            ((Apple)x).info();    
            
        }
        
        x.getClass().isInstance(apple);//声明apple对象的类必须是编译时可知的

2.2 RTTI与反射的区别

使用RTTI必须满足一个条件：如果想知道泛化引用的确切类型，那么这个类在编译时必须可知。

通过RTTI可以查询到某个对象的确切类型，这个类型在编译时必须已知（要么是系统类库中的类，要么是你自己在代码中定义的类，因为一个Class定义最终会转换成一个.class文件，所以编译器会去查找看有没有对应的.class文件，没有的话在编译时就报错“错误：找不到符号”，这个过程是在编译阶段完成的），这样才能使用RTTI识别它。换句话说，在编译时，编译器必须知道所有要通过RTTI来处理的类。

RTTI与反射的区别如下：

RTTI：由编译器在编译时打开和检查*.class文件。

反射机制：由JVM在运行时打开和检查*.class文件。

            Class clazz1 = Class.forName("rtti.Apple");    //在编译阶段编译器不会检查和打开字符串"rtti.Apple"指定的类对应的.class文件，而是在运行期间由JVM加载。
            System.out.println(clazz1.getName());    

        Fruit fruit = new Bnana();    //编译阶段编译器会去查找Fruit类和Apple类各自对应的.class文件。
        Class clazz2 = fruit.getClass();
        System.out.println(clazz2.getName());

疑问：编译器在编译时打开和检查*.class文件的这一过程中具体都干了什么？

3.1 反射机制

维基百科的定义：In computer science, reflection is the ability of a computer program to examine (see type introspection) and modify the structure and behavior (specifically the values, meta-data, properties and functions) of the program at runtime.

并不是所有的类型都能在编译的时候确定下来（比如有输入一个类名显示出这个类的所有方法的程序），所以得把打开和检查.class文件的工作推到运行时再处理。典型的场景是“基于构件的编程”和远程方法调用(RMI) 。

Class.forName()生成的结果在编译时是不可知的，也就是说，编译时不会去验证参数字符串对应的类是否存在。这都是在运行的时候由JVM处理的，所以这个方法会抛出ClassNotFoundException。

Class类支持反射，是在java.lang.reflect中包含了Field/Method/Constructor类，每个类都实现了Member接口。这些类型的对象都是由JVM在运行时创建的，用来表示未知类里对应的成员。如可以用Constructor类创建新的对象，用get()和set()方法读取和修改与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。同时，还可以调用getFields()、getMethods()、getConstructors()等方法来返回表示字段、方法以及构造器的对象数组。这样，未知的对象的类信息在运行时就能被完全确定下来，而在编译时不需要知道任何信息。

3.2 如何获取Class对象

（1）Class.forName(String packageNamePlusClassName);

（2）Object.getClass();

（3）类字面常量

3.3泛化的Class引用

（1）通配符方式

Class<?> intClass  = int.class;

（2）extends实现范围限定

Class<? extends NUmber> bounded = int.class;

（3）super方式

Class<Apple> apClass = Apple.class;
Apple apple = apClass.newInstance();
Class<? super Fruit> up = apClass.getSuperclass();

3.4 instanceof与class的等价性

（1）instanceof 与 isInstance()生成的结果完全一样，equal与==也一样。

（2）Instanceof与isInstance()保持了类型的概念，它指的是“你是这个类，或者是这个类的派生类吗？”

（3）equal与==比较实际的Class对象，没有考虑继承——它或者是这个确切的类型，或者不是。

4.总结

JAVA编程思想，第14章末尾的总结一节的概括：

第1段的意思，使用RTTI可以发现引用变量的确切类型，然后根据引用变量具体的确切类型执行对应的操作（类似switch语句，P327的例子）。这种方式就没有使用多态，失去了多态的价值。所以尽量使用多态机制，只是在必需的时候才使用RTTI。

第2-4段，概述了RTTI在部分场景下的优势，分别举例说明使用RTTI可以解决的问题。

参考资料

JAVA编程思想，第14章，第8章 8.5.2

http://www.cnblogs.com/zhguang/p/3091378.htm

http://blog.csdn.net/cannel_2020/article/details/7226108

http://blog.csdn.net/a81895898/article/details/8457623

http://blog.sina.com.cn/s/blog_548c8a8301013j6u.html