Java编程思想——第14章 类型信息（一）RTTI
运行时类型信息使得你可以在程序运行时发现和使用类型信息。Java是如何让我们在运行时识别对象和类的信息得呢？
主要有两种方式：1.传统RTTI,他假定我们在编译期间已经知道了所有类型；2.反射，它允许我们在运行时发现和使用类的信息。
一、为什么需要RTTI
我们来看一个例子：
这是一个典型的类层次结构图，基类位于顶部，派生类向下扩展。面向对象编程中的基本目的是：让代码只操纵对基类（Shape）的引用。这样，如果添加一个新类（比如从Shape派生的Rhomboid）来扩展程序就不会影响原来代码了。这个例子中Shape接口动态绑定了draw()方法，目的就是让客户端程序员用泛化的Shape引用来调用draw()。draw()在所有派生类里都会被覆盖，并且由于它是被动态绑定的，所以即使是通过泛化的Shape引用来调用，也能产生正确的行为。这就是多态。
abstract class Shape { void draw() { System.out.println(this + ".draw()"); } @Override abstract public String toString(); } class Circle extends Shape { @Override public String toString() { return "Circle"; } } class Square extends Shape { @Override public String toString() { return "Square"; } } class Triangle extends Shape { @Override public String toString() { return "Triangle"; } } public class Shapes { public static void main(String[] args) { List<Shape> shapes = Arrays.asList(new Circle(), new Triangle(), new Square()); for (Shape shape : shapes) { shape.draw(); } } }
结果：
Circle.draw()
Triangle.draw()
Square.draw()
分析：1.toString()被声明为abstract,以此强制继承者覆写该方法，并且防止对无格式的Shape的实例化。
2.如果某个对象出现在字符串表达式中（比如“+”，字符串对象的表达式），toString()会自动被调用，以生成该对象的String。
3.当Shape派生类的对象放入List<Shape>的数组时会向上转型，但是当向上转型为Shape时也丢失了Shape对象的具体类型。对数组而言，他们都只是Shape类的对象。
4.当从数组中取出元素时（这种容器把所有的事物都当作Object持有），将结果转型会Shape。这是RTTI的最基本使用形式，因为在Java中所有的类型转换都是在运行时进行正确性检查的。这也是RTTI名字的含义：在运行时，识别一个对象的类型。
5.但是例子中RTTI转型并不彻底：Object被转型为Shape而不是具体的派生类型，这是因为List<Shape>提供的信息是保存的都是Shape类型。在编译时，由容器和泛型保证这点，在运行时，由类型转换操作来确保这点。
6.Shape对象具体执行什么，是由引用所指向的具体对象（派生类对象）决定的，而现实中大部分人正是希望尽可能少的了解对象的具体类型，而只是和家族中一个通用的类打交道,如:Shape,使得代码更易读写，设计更好实现，理解和改变，所以“多态”是面向对象编程的基本目标。
二、Class对象
使用RTTI,可以查询某个Shape引用所指向的对象的确切类型，然后选择或者剔除某些特性。要理解RTTI在Java中的工作原理，首先应该知道类型信息在运行时是如何表示的。Class对象承担了这项工作，Class对象包含了与类有关的信息。Class对象就是用来创建所有对象的，Java使用Class对象来执行其RTTI，Class类除了执行转型操作外，还有拥有大量的使用RTTI的其他方式。
每当编写并编译一个新类，就会生成一个Class对象，被存在同名的.class文件中。运行这个程序的Java 虚拟机（JVM）使用被称为“类加载器”的子系统，生成这个类的对象。类加载器子系统实际上可以包含以挑类加载链，但是只有一个原生类加载器，它是JVM实现的一部分。原生类加载器加载的通常是加载本地盘的内容，这条链通常不需要添加额外的类加载器，但是如果有特殊需求比如：支持Web服务器应用，那么就要挂接额外的类加载器。
所有的类在被第一次使用时，动态加载到JVM中。当第一个对类的静态成员的引用被创建时，就会加载这个类。这也证明构造器是静态方法，使用new操作符创建类的新对象也会被当作对类的静态成员的引用。因此，Java程序在开始运行之前并未完全加载，各个部分在必须时才会加载。类加载器首先检查这个类的Class对象是否已加载，如果尚未加载，默认的类加载器就会根据类名查找.class文件。
一旦某个类的Class对象被加载入内存，它就被用来创建这个类的所有对象：
class Candy { static { System.out.println("Loading Candy"); } } class Gum { Gum() { System.out.println("Constructed Gum"); } static { System.out.println("Loading Gum"); } } public class SweetShop { public static void main(String[] args) { System.out.println("inside main"); new Candy(); try { Class.forName("Gum"); } catch (ClassNotFoundException e) { e.printStackTrace(); } new Gum(); new Candy(); } }
结果：
Inside main
Loading Candy
Loading Gum
Constructed Gum
Class.forName(）会让类初始化：每个类都有一个static子句，该子句在类被第一次加载时执行，注意第二次加载时候就不走了。
Class.forName("");这个方法是Class类的一个static成员。Class对象就和其他对象一样 我们可以获取并操作它的引用（这也就是类加载器的工作）。forName()是取得Class对象引用的一种方法，Class clazz = Class.forName("xxx"); xxx必须是带包名的全名!!! 如果你已经得到了一个类的引用xxx，还可以通过：Class clazz = xxx.getClass();方式获取class对象。Class包含很多方法 其中比较常用的有：
public T newInstance() 得到一个实例 相当于new
public native boolean isInstance(Object obj) 是否是参数类的一个实例
public native boolean isAssignableFrom(Class<?> cls) 判定此Class对象所表示的类或接口与指定的Class参数所表示的类或接口是否相同，或是否是其超类或超接口
public native boolean isInterface();判断是否是接口
public native boolean isArray();判断是否是数组
public native boolean isPrimitive();判断是否是基本类型
public boolean isAnnotation() 判断是否是注解
public boolean isSynthetic() 判断是否是同步代码块
public String getName() 返回带包的全名，包含类的类型信息（是引用类型 还是各种基本类型）
public ClassLoader getClassLoader() 获取该类的类加载器。
public TypeVariable<Class<T>>[] getTypeParameters() 获取泛型
public native Class<? super T> getSuperclass(); 获取父类和父类泛型
public Package getPackage() 获取包名
public Class<?>[] getInterfaces() 获取该类实现的接口列表
public Type[] getGenericInterfaces() 获取实现的接口列表及泛型
public native Class<?> getComponentType() 返回表示数组组件类型的 Class。如果此类不表示数组类，则此方法返回 null。如果此类是数组，则返回表示此类组件类型的 Class
public native int getModifiers() 返回类的修饰符
public native Object[] getSigners();// 我目前还不知道是干什么的如果有明确用处请评论告诉我 万分感谢
native void setSigners(Object[] signers)
public Method getEnclosingMethod() 获取局部或匿名内部类在定义时所在的方法
public String getSimpleName() 获取最简单的那个类名
public String getCanonicalName() 带有包名的类名
public String getTypeName() 如果是数组的话[类名] 否则和getSimpleName一样
public Field[] getFields() 获取类中public的字段
public Field[] getDeclaredFields() 获取类中所有字段
public Class<?>[] getClasses() 获取该类以及父类所有的public的内部类
public Class<?>[] getDeclaredClasses() 获取该类所有内部类，不包含父类的
public Method[] getMethods() 获取该类及父类所有的public的方法
public Method[] getDeclaredMethods() 获取该类中所有方法 ，不包含父类
public Constructor<?>[] getConstructors() 获取所有public的构造方法
public Constructor<?>[] getDeclaredConstructors() 获取该类所有构造方法
public Field getField(String name) 根据字段名public获取字段
public Field getDeclaredField(String name) 根据字段名所有获取字段
public Method getMethod(String name, Class<?>... parameterTypes) 根据方法名和参数获取public方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 根据方法名和参数获取所有方法
public Constructor<T> getConstructor(Class<?>... parameterTypes) 根据参数获取public构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 根据参数获取所有构造反方法、
... 如遗漏重要方法 请提醒 谢谢~
类的字面常量
Java还有另一种方式生成对Class的引用，即使用字面常量：ClassDemo.class; 这种方式 简单 高效（因为不用初始化类），且这种方式同样适用于接口，数组，基本类型。对于基本类型的包装类，还有一个标准字段TYPE:
boolean.class = Boolean.TYPE char.class = Character.TYPE byte.class = Byte.TYPE short.class = Short.TYPE int.class = Integer.TYPE long.class = Long.TYPE float.class = Float.TYPE double.class = Double.TYPE void.class = Void.TYPE
使用这种方式创建对象的引用时，不会自动初始化该Class对象，为了使用类而做的准备工作实际包含三个步骤：
1.加载，由类加载器进行。该步骤将查找字节码，并从这些字节码中创建一个Class对象。
2.连接，在连接阶段将验证类中的字节码，为静态域分配存空间，如果有需要，将解析这个类创建的对其他类的所有引用。
3.初始化，如果该类具有父类，则对其初始化，执行静态初始化器和静态初始化块。
初始化在对静态方法（构造器是隐式地静态）或非常数静态域进行首次引用时才会执行：
class InitableA { static final int staticFinalA = 47; static final int staticFinalB = ClassInitialization.random.nextInt(1000); static { System.out.println("Initializing InitableA"); } } class InitableB { static int staticNoFinal = 147; static { System.out.println("Initializing InitableB"); } } public class ClassInitialization { public static Random random = new Random(47); public static void main(String[] args) { System.out.println(InitableA.staticFinalA); System.out.println(InitableA.staticFinalB); System.out.println(InitableB.staticNoFinal); } }
结果：
1 Initializing InitableA 258 Initializing InitableB 147
如果一个static final 是"编译期常量" ，就像 staticFinalA 那么需要对它的类进行初始化就可以读取，但是 staticFinalB 却会使类初始化,因为它不是编译期常量；只有static修饰符的 staticNoFinal 在对它读取之前，要先进行链接，为这个域分配存储空间并且初始化该存储空间。
泛型化的Class引用
通过使用泛型语法，可以让编译器强制执行额外的类型检查：Class<Integer> intClass= int.class; 如果想放松限制，可以使用通配符"?":Class<?> anyClass = AnyClass.class;如果想限定某类型的子类可以使用extends 关键字：Class<? extends Number> numCLass = int.class; numClass = double.class;
当使用泛型语法Class<Toy>用于创建Class对象时，newInstance()将返回该对象得确切信息而不只是Object。
如果你手头是Toy的父类ToyFather，toyClass.getSuperclass()方法却只能返回 Class<? super Toy> 而不是确切的ToyFather ,并且在newInstance()时返回Object。
三、类型转换前先做检查
迄今为止我们已知RTTI形式包含：
1）传统的类型转换，“（Shape）” ,由RTTI确保类型转换的正确性，检查未通过会报ClassCastException.
2）代表对象的类型的Class对象，通过查询Class对象可以获得运行时所需的信息。
向上转型或向下转型是根据类层次结构图排列顺序定义的（父类在上子类在下）;由于Circle一定是一个Shape所以向上转型不用有任何转型操作，而向下转型编译器则无法知道Shape以外的任何具体信息，只能使用显示类型转换，以告知编译器额外的信息。
3）instanceof 它可以判断对象是不是某个特定类型的实例。
四、注册工厂
工厂方法设计模式，将对象的创建工作交给类自己完成。工厂方法可以被多态地调用，从而为你创建恰当类型的对象。简易版本：
public interface FactoryDemo<T> {
T create();
}
create返回的就是对应的对象.
五、instanceof 与 Class的等价性
在查询类型信息时，以instanceof的形式（即使用instanceof的形式或isInstance()的形式）与直接比较Class对象有一个比较重要的差别：
instanceof:保持了类型的概念，指的是：“你是这个类或这个类的派生类么”。
而 == 或 equals() 比较的只是Class对象，没有考虑继承。
