Java编程思想-类型信息RTTI和反射

Contents

1. 1. Class常用方法
2. 2. RTTI Run-Time Type Infomation 运行时类型信息
   1. 2.1. Class类与Class对象
   2. 2.2. Class.forName(String str)
   3. 2.3. 类字面变量
   4. 2.4. 范化的Class引用
   5. 2.5. Class.newInstance()
   6. 2.6. 类型检查
3. 3. 反射 Reflection：运行时的类信息
   1. 3.1. 获取类的class对象
   2. 3.2. 获取类的Fields
   3. 3.3. 获取类的Method
   4. 3.4. 获取类的Constructor

来源1
来源2
来源2

有Java中，我们如何在运行时识别类和对象的信息？有两种方法，一是传统的RTTI，另一种是反射。

RTTI： 运行时类型识别，在编译与运行时已知类型。
反射机制：运行期对模块无任何了解。

RTTI与反射的区别？
RTTI编译时类型必须已知。 编译器在编译时打开和检查.class文件。
Reflection编译时不知晓类型,.class文件在编译时候不可获取的，所以在运行时打开和检查.class文件。

另外，RTTI有时能解决效率问题。当程序中使用多态给程序的运行带来负担的时候，可以使用RTTI编写一段代码来提高效率。

Class常用方法

1. getName()
   由于历史原因
   Double[].class.getName() 返回”[Ljava.lang.Double;”
   int[].class.getName() 返回”[“
2. forName()
   静态 ：立即加载类型信息
3. getClass()
4. T.class
   动态：不理解加载 类型信息
   代表匹配的类对象

   一个类对象表示一个“类型”
   

   这个类型未必是类，例如int不是类，int.clss是一个Class类型的对象
   5.Class
   限定Class引用必须是T类型
   问题

   Class<Number> genericNumberClass = int.class
   Integer继承自Number
   Integer.Class对象不是Number.Class对象的子类
   

   解决以上问题

   通配符" ? "
   <? extends Number>
   

RTTI Run-Time Type Infomation 运行时类型信息

• RTTI的三种方法？

1. 强制类型转换
   SuperClass instance = (SuperClass) sub;
2. 利用Class对象
   Class class = Class.forName(“className”);
   Class class = objectInstance.getClass();
   Class class = ObjectInstance.class
3. ‹通过比较识别类型
   if (sub instanceof SubClass) {}
   if ( Class.isInstance() )

##为什么需要RTTI？
越是优秀的面向对象设计，越是强调高内聚低耦合，正如依赖倒转原则所说：“无论是高层模块还是低层模块，都应该针对抽象编程”。

比如说我们有一个抽象父类：
Shape draw()
以下是三个具体类：
Circle draw()
Square draw()
Triangle draw()
某些情况下，我们持有Shape，但却远远不够——因为我们想要针对它的具体类型进行特殊处理，然而我们的设计完全针对抽象，所以在当前上下文环境中无法判断具体类型。
因为RTTI的存在，使得我们在不破坏设计的前提下得以达到目的。

总的来说分为以下两点

1. 多态 - 实例都被向上转型为父类引用，实例调用相应方法时，需要知道当前父类型引用的具体类型，并从中查找相应方法。
2. IDE - 获取任意类的所有字段和方法。
   跨网络的远程平台上创建和运行对象的能力
   从磁盘文件，或者网络连接中获取一串字节（表示类）
   对象序列化

Class类与Class对象

事实上，每一个类都持有其对应的Class类的对象的引用（Object类中的getClass()能让我们获取到它），其中包含着与类相关的信息。
非常容易注意到，针对每一个类，编译Java文件会生成一个二进制.class文件，这其中就保存着该类对应的Class对象的信息。
.class是用于供类加载器使用的文件
Java程序在运行之前并没有被完全加载，各个部分是在需要时才被加载的。

为了使用类而作的准备包含三步：

1. 加载。由类加载器执行，查找字节码，创建一个Class对象。
2. 链接。验证字节码，为静态域分配存储空间，如果必需的话，会解析这个类创建的对其他类的所有引用（比如说该类持有static域）。
3. 初始化。如果该类有超类，则对其初始化，执行静态初始化器[注]和静态初始化块。
   注：原文为static initializers，经查看Thinking in Java，其意应为静态域在定义处的初始化，如：
   static Dog d = new Dog(0);。

所有的类都是在对其第一次使用时，动态加载到JVM中去的。当程序创建第一个对类的静态成员的引用时，JVM会使用类加载器来根据类名查找同名的.class——一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。构造器也是类的静态方法，使用new操作符创建新对象会被当作对类的静态成员的引用。
注意特例：如果一个static final值是编译期常量，读取这个值不需要对类进行初始化。所以说对于不变常量，我们总是应该使用static final修饰。

Class.forName(String str)

Class类有一个很有用的静态方法forName(String str)，可以让我们对于某个类不进行创建就得到它的Class对象的引用，例如这个样子：

try {
     Class toyClass = Class.forName("com.duanze.Toy"); // 注意必须使用全限定名
} catch (ClassNotFoundException e) {

}

然而，使用forName(String str)有一个副作用：如果Toy类没有被加载，调用它会触发Toy类的static子句（静态初始化块）。

类字面变量

与之相比，更好用的是类字面常量，像是这样:

Class toyClass = Toy.class;

支持编译时检查，所以不会抛出异常。使用类字面常量创建Class对象的引用与forName(String str)不同，不会触发Toy类的static子句（静态初始化块）。所以，更简单更安全更高效。
类字面常量支持类、接口、数组、基本数据类型。

Class.forName（String className）使用装载当前类的类装载器来装载指定类。因为class.forName(String className)方法内部调用了Class.forName(className, true, this.getClass().getClassLoader())方法，如你所见，第三个参数就是指定类装载器，显而易见，它指定的是装载当前类的类装载器的实例，也就是this.getClass().getClassLoader();
你可以选择手动指定装载器。

范化的Class引用

通过范型以及通配符，我们能对Class对象的引用进行类型限定，像是：

Class<Integer> intClass = int.class; // 注意右边是基本数据类型的类字面常量

这样做的好处是能让编译器进行额外的类型检查。
知道了这一点以后，我们可以把之前的例子改写一下：

Class toyClass = Toy.class;
Class<?> toyClass = Toy.class;

虽然这两句是等价的，但从可读性来说Class<?>要优于Class，这说明编程者并不是由于疏忽而选择了非具体版本，而是特意选择了非具体版本。

Class.newInstance()

既然拿到了包含着类信息的Class对象的引用，我们理应可以构造出一个类的实例。Class.newInstance()就是这样一个方法，比如：

try {
    Class<?> toyClass = Class.forName("com.duanze.Toy"); 
    Object obj = toyClass.newInstance();
} catch (ClassNotFoundException e) {

}

// Two
Class<?> toyClass = Toy.class;
Object obj = toyClass.newInstance();

使用newInstance()创建的类，必须带有默认构造器。
由于toyClass仅仅只是一个Class对象引用，在编译期不具备更进一步的类型信息，所以你使用newInstance()时只会得到一个Object引用。如果你需要拿到确切类型，需要这样做：

Class<Toy> toyClass = Toy.class;
Toy obj = toyClass.newInstance();

但是，如果你遇到下面的情况，还是只能拿到Object引用：

Class<SubToy> subToyClass = SubToy.class;
Class<? super SubToy> upClass = subToy.getSuperclass(); // 希望拿到SubToy的父类Toy的Class对象引用
// This won't compile:
// Class<Toy> upClass = subToy.getSuperclass();
// Only produces Object:
Object obj = upClass.newInstance();

虽然从常理上来讲，编译器应该在编译期就能知道SubToy的超类是Toy，但实际上却并不支持这样写：

// This won't compile:
Class<Toy> upClass = subToy.getSuperclass();

而只能够接受：

Class<? super SubToy> upClass = subToy.getSuperclass(); // 希望拿到SubToy的父类Toy

这看上去有些奇怪，但现状就是如此，我们惟有接受。好在这并不是什么大问题，因为转型操作并不困难。

类型检查

在进行类型转换之前，可以使用instanceof关键字进行类型检查，像是：

if ( x instanceof Shape ) {
     Shape s = (Shape)x;
}

一般情况下instanceof已经够用，但有些时候你可能需要更动态的测试途径:Class.isInstance(Class clz):

Class<Shape> s = Shape.class;
s.isInstance(x);

可以看到，与instanceof相比，isInstance()的左右两边都是可变的，这一动态性有时可以让大量包裹在if else…中的instanceof缩减为一句。

反射 Reflection：运行时的类信息

不知道你注意到了没有，以上使用的RTTI都具有一个共同的限制：在编译时，编译器必须知道所有要通过RTTI来处理的类。

但有的时候，你获取了一个对象引用，然而其对应的类并不在你的程序空间中，怎么办？（这种情况并不少见，比如说你从磁盘文件或者网络中获取了一串字串，并且被告知这一串字串代表了一个类，这个类在编译器为你的程序生成代码之后才会出现。）

Class类和java.lang.reflect类库一同对反射的概念提供了支持。反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于RTTI和反射之间的真正区别只在于：

• RTTI，编译器在编译时打开和检查.class文件
• 反射，运行时打开和检查.class文件

明白了以上概念后，什么getFields(),getMethods(),getConstructors()之类的方法基本上全都可以望文生义了。

java.lang.reflect
这些类型的对象是由JVM在运行时创建的，可以表示未知类里对应的成员：
|类名 |作用|
|——|—–|
|Class | 代表一个类。|
|Field |
代表类的成员变量（成员变量也称为类的属性）。？对象？
get() set()方法读取和修改与Field对象关联的字段|
|Method | 代表类的方法。 用invoke()方法调用与此类关联的方法|
|Constructor |代表类的构造方法。|
|Array | 提供了动态创建数组，以及访问数组的元素的静态方法。|

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

Java反射机制提供如下功能：

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判段任意一个类所具有的成员变量和方法
• 在运行时调用任一个对象的方法
• 在运行时创建新类对象
  在使用Java的反射功能时，基本首先都要获取类的Class对象，再通过Class对象获取其他的对象。

获取类的class对象

1. 调用getClass
   Boolean var1 = true;
   Class<?> classType2 = var1.getClass();
   System.out.println(classType2);
   输出：class java.lang.Boolean

2. 运用.class 语法
   Class<?> classType4 = Boolean.class;
   System.out.println(classType4);
   输出：class java.lang.Boolean

3. 运用static method Class.forName()
   Class<?> classType5 = Class.forName(“java.lang.Boolean”);
   System.out.println(classType5);
   输出：class java.lang.Boolean

4. 运用primitive wrapper classes的TYPE 语法
   这里返回的是原生类型，和Boolean.class返回的不同
   Class<?> classType3 = Boolean.TYPE;
   System.out.println(classType3);
   输出：boolean

获取类的Fields

可以通过反射机制得到某个类的某个属性，然后改变对应于这个类的某个实例的该属性值。JAVA 的Class类提供了几个方法获取类的属性。

1. public Field getField(String name)
   返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段
2. public Field[] getFields()
   返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段
3. public Field getDeclaredField(String name)
   返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段
4. public Field[] getDeclaredFields()
   返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段

可见getFields和getDeclaredFields区别：
getFields返回的是申明为public的属性，包括父类中定义，
getDeclaredFields返回的是指定类定义的所有定义的属性，不包括父类的。

获取类的Method

通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法
Class类提供了几个方法获取类的方法。

1. public Method getMethod(String name, Class<?>… parameterTypes)
   返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法
2. public Method[] getMethods()
   返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法
3. public Method getDeclaredMethod(String name,Class<?>… parameterTypes)
   返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法
4. public Method[] getDeclaredMethods()
   返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法

获取类的Constructor

通过反射机制得到某个类的构造器，然后调用该构造器创建该类的一个实例
Class类提供了几个方法获取类的构造器。

1. public Constructor getConstructor(Class<?>… parameterTypes)
   返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法
2. public Constructor<?>[] getConstructors()
   返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法
3. public Constructor getDeclaredConstructor(Class<?>… parameterTypes)
   返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法
4. public Constructor<?>[] getDeclaredConstructors()
   返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。它们是公共、保护、默认（包）访问和私有构造方法