Java类型信息之RTTI

软件工程的一个核心问题就是软件的复用和扩展。面向对象思想通过封装，继承，派生等机制有效地解决了这个问题。但需求总是变幻莫测，不可琢磨，在面向对象这栋恢宏的大厦旁，还漂浮着一朵乌云，从而导致了RTTI的登场。

正是因为RTTI的存在，在软件世界里，无间道是会分分钟暴露的：

1.缘起

考虑一下面向对象思想发源地之一的CAD系统：

package typeinfo._01_rtti;

import java.util.Arrays;
import java.util.List;

interface Shape {
    void draw();
}

class CAD {
    public void draw(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle draw()");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square draw()");
    }
}

class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Triangle draw()");
    }
}

public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = Arrays.asList(
                new Circle(), new Square(), new Triangle()
        );

        CAD cad = new CAD();
        cad.draw(shapes);
    }
}

输出结果：

Circle draw()
Square draw()
Triangle draw()

代码点评：

Shape是基类，根据多态机制，Shape引用可以被它的子类引用赋值，并通过动态绑定在虚函数draw调用时正确调用子类的draw。

依靠这种机制，我们可以轻松的在上层的CAD类中写出通用的draw方法，而不用管Shape到底会有多少子类。

现在忽然来了新的需求，要求CAD在draw的时候把用户指定类型的对象高亮显示，假设用户指定了Circle类型，那就是要求把当前图形中的所有的Circle对象高亮显示。因为上层的CAD代码无法分辨具体的子类类型，所以功能无法实现。

痛定思痛，这些面向对象的大师们决定引入RTTI（Run-Time Type Identification）运行时类型识别，简单的说就是运行时你只要给我一个引用，就我能准确的告诉你它是什么具体类型的。

尽管RTTI名声不好，大师们的建议是能少用就少用，但是具有讽刺意味的是，几乎没有哪门语言能跳过RTTI，不同的只是各种各样的语法区别：

• Python语言的type

• Java语言的getClass

• javascript语言的typeof

• C++语言的typeid

• C#语言的GetType

• 。。。

2.Java语言的class

Java语言的class其实是一个Class类的对象，任何类都有一个这样的对象，实际上，这是对象又是Java类加载器加载类时自动带上的，要理清这些角色之间的复杂关系，请看下图：

1. 所有new出来的对象共享该类型的class对象

2. class对象是Class类的一个实例

3. Class类是被ClassLoader带进来的

4. ClassLoader通过加载class字节码导入类

口说无凭，直接来段测试代码吧：

@Test
public void testClassLevel() {
    class Test {
    }

    Test a = new Test();
    System.out.println(a.getClass());
    Test b = new Test();
    System.out.println(b.getClass());

    System.out.println(a.getClass() == a.getClass());

    System.out.println(Test.class);
    System.out.println(Test.class.getClassLoader());
}

输出结果：

class typeinfo._01_rtti.ClassClassTest$1Test
class typeinfo._01_rtti.ClassClassTest$1Test
true
class typeinfo._01_rtti.ClassClassTest$1Test
jdk.internal.loader.ClassLoaders$AppClassLoader@726f3b58

代码点评：

new出来的对象可以通过getClass得到该类型的class对象

所有new出来的对象getClass得到的class对象都是同一个

class对象可以通过Test.class的形式快速引用

class对象可以通过getClassLoader得到类加载器

关于类加载器的细节，将单独有一篇文章介绍

2.引用class

引用class最简单的方式就是通过XXX.class的语法直接引用：

public void print(Class meta) {
    System.out.println(meta);
}

@Test
public void testClassClass() {
    print(boolean.class);
    print(char.class);
    print(byte.class);
    print(short.class);
    print(int.class);
    print(long.class);
    print(float.class);
    print(double.class);

    print(void.class);
    print(Object.class);
    print(String.class);
}

输出结果：

boolean
char
byte
short
int
long
float
double
void
class java.lang.Object
class java.lang.String

代码点评：

没错，基本类型也有class，甚至是void也有class

class及其Class就是Java类型体系的核心

还有内置的数组呢？同样不能例外：

@Test
public void testClassClassArray() {
    print(boolean[].class);
    print(char[].class);
    print(byte[].class);
    print(short[].class);
    print(int[].class);
    print(long[].class);
    print(float[].class);
    print(double[].class);
    
    //print(void[].class);
    print(Object[].class);
    print(String[].class);
}

输出结果：

class [Z
class [C
class [B
class [S
class [I
class [J
class [F
class [D
class [Ljava.lang.Object;
class [Ljava.lang.String;

代码点评：

void[]是不存在的

输出的这些奇怪的字符，这是历史原因造成的，其实它就表示数组

通过对象得到class要用getClass：

@Test
public void testClassGetClass() {
    Boolean t = true;
    Character c = 'A';
    Byte b = 0;
    Short s = 0;
    Integer i = 0;
    Long l = 0L;
    Float f = 1.0f;
    Double d = 1.0;

    print(t.getClass());
    print(c.getClass());
    print(b.getClass());
    print(s.getClass());
    print(i.getClass());
    print(l.getClass());
    print(f.getClass());
    print(d.getClass());

    //Void v = new Void();
    Object obj = new Object();
    String str = new String();
    //print(v.getClass());
    print(obj.getClass());
    print(str.getClass());
}

输出结果：

class java.lang.Boolean
class java.lang.Character
class java.lang.Byte
class java.lang.Short
class java.lang.Integer
class java.lang.Long
class java.lang.Float
class java.lang.Double
class java.lang.Object
class java.lang.String

代码点评：

基本类型不能生成对象引用，只好用它们的包装类对象引用

除了Void，其它的与XXX.class是一致的

其实数组也是对象，所以下面的代码也是成立的：

@Test
public void testClassGetClassArray() {
    boolean[] t = {true};
    char[] c = {'A'};
    byte[] b = {0};
    short[] s = {0};
    int[] i = {0};
    long l[] = {0L};
    float f[] = {1.0f};
    double[] d = {1.0};

    print(t.getClass());
    print(c.getClass());
    print(b.getClass());
    print(s.getClass());
    print(i.getClass());
    print(l.getClass());
    print(f.getClass());
    print(d.getClass());

    Object[] obj = {new Object()};
    String[] str = {new String()};
    print(obj.getClass());
    print(str.getClass());
}

输出结果：

class [Z
class [C
class [B
class [S
class [I
class [J
class [F
class [D
class [Ljava.lang.Object;
class [Ljava.lang.String;

对于Java的基本类型，还可以通过XXX.TYPE的形式引用class，这是基本类型所特有的绿色通道：

@Test
public void testClassType() {
    print(Boolean.TYPE);
    print(Character.TYPE);
    print(Byte.TYPE);
    print(Short.TYPE);
    print(Integer.TYPE);
    print(Long.TYPE);
    print(Float.TYPE);
    print(Double.TYPE);

    print(Void.TYPE);
    //print(Object.TYPE);
    //print(String.TYPE);
}

输出结果：

boolean
char
byte
short
int
long
float
double
void

3.class与泛型

原则上，所有的class都是Class类的对象，但是这太粗略了。我们可以通过泛型进一步细化Class类：

@Test
public void testGeneric() {
    Class intClass = int.class;
    intClass = double.class;

    Class<Integer> genericIntClass = int.class;
    genericIntClass = Integer.class; // Same thing
    // genericIntClass = double.class; // Illegal
}

代码点评：

默认的Class即可以引用int.class，也可以引用double.class

Class<Integer>就只能引用int.class了，不可以引用double.class

当然了，在泛型的世界里，更习惯用通配符Class<?>代替Class，以表明它那高贵的泛型身份：

@Test
public void testWildcard() {
    Class<?> intClass = int.class;
    intClass = double.class;
    intClass = String.class;
}

当然了，还不能忘了泛型的限定符：

@Test
public void testBounded() {
    Class<? extends Number> numberClass = int.class;
    numberClass = double.class;
    numberClass = Number.class;
    //numberClass = String.class;
}

这里通过限定符的限制，有效的避免了String.class的引用。