Java类型信息之RTTI

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

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

Java类型信息之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类加载器加载类时自动带上的,要理清这些角色之间的复杂关系,请看下图:

Java类型信息之RTTI

  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的引用。

上一篇:【odoo14】第十六章、odoo web库(OWL)


下一篇:使用TextKit