Java类型信息

一、RTTI简介

RTTI（Run-Time Type Identification）运行时类型识别，使得而我们可以在程序运行是发现和使用类型信息。

面向对象的本质是是：让代码只操纵对基类的引用，如果扩展一个新类也不需要修改代码。在调用方法时通过动态绑定，用派生类覆盖基类的操作。也就是多态。

二、Class对象

2.1 简介

• 每一个类都有一个Class对象，存储在与类同名的.class文件中

2.2 对象的加载

• 每当编写并且编译了一个新类，就会产生一个Class对象，存储在同名的.class文件中
• 当程序创建第一个对类的静态成员引用时，就会加载这个类。构造器也是类的一个静态方法(虽然没有static)，因此使用new创建类的对象也被当作对类的静态成员引用
• 类加载器首先会检查这个类的Class对象是否已经被加载，如果没被加载，默认的类加载器就会根据类名查找.class文件,该类的Class对象就在.class文件里
• 一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象

class Candy {
    static {   System.out.println("Loading Candy"); }
}

class Gum {
    static {   System.out.println("Loading Gum"); }
}

class Cookie {
    static {   System.out.println("Loading Cookie"); }
}

public class SweetShop {
    public static void print(Object obj) {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        print("inside main");
        new Candy();
        new Candy(); //这时类已经加载了，不会打印了
        print("After creating Candy");
        try {
            Class.forName("com.it06.Gum");
        } catch(ClassNotFoundException e) {
            print("Couldn't find Gum");
        }
        print("After Class.forName(\"Gum\")");
        new Cookie();
        try {
            System.out.println(Class.forName("com.it06.Cookie"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        print("After creating Cookie");
    }
}/*
inside main
Loading Candy
After creating Candy
Loading Gum
After Class.forName("Gum")
Loading Cookie
class com.it06.Cookie
After creating Cookie
*/

2.3 取得Class对象引用的两种方法

2.3.1 Class.forName()

通过类的路径获取类的Class对象

class Cookie {
    static {   System.out.println("Loading Cookie"); }
}
public class SweetShop {
    public static void main(String[] args) {
        new Cookie();
        try {
            Class A = Class.forName("com.it06.Cookie");
            System.out.println("forName = A:"+ A.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}/*
Loading Cookie
forName = A:com.it06.Cookie
*/

2.3.2 getClass()

通过实例对象获取类的Class对象

class Cookie {
    static {   System.out.println("Loading Cookie"); }
}
public class SweetShop {
    public static void main(String[] args) {
        Cookie cookie = new Cookie();
        Class B = cookie.getClass();
        System.out.println("new=B:"+B.getName());
    }
}/*
Loading Cookie
new=B:com.it06.Cookie
*/

三、类字面值常量

在Java中存在另一种方式来生成Class对象的引用，它就是Class字面常量

Class C = Cookie.class;

这种方式相对前面两种方法更加简单，更安全，因为它在编译器就会受到编译器的检查同时由于无需调用forName方法效率也更高
通过字面量的方法获取Class对象的引用不会自动初始化该类

对于基本类型的包装器类，还有一个标准字段TYPE，而这个TYPE就是一个引用，指向基本数据类型的Class对象，其等价转换如下，一般情况下更倾向使用.class的形式

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;

3.1 类加载过程

详见类加载过程

class Initable {
    //编译期静态常量
    static final int staticFinal = 47;
    //非编期静态常量
    static final int staticFinal2 =
            ClassInitialization.rand.nextInt(1000);
    static {
        System.out.println("Initializing Initable");
    }
}

class Initable2 {
    //静态成员变量
    static int staticNonFinal = 147;
    static {
        System.out.println("Initializing Initable2");
    }
}

class Initable3 {
    //静态成员变量
    static int staticNonFinal = 74;
    static {
        System.out.println("Initializing Initable3");
    }
}

public class ClassInitialization {
    public static Random rand = new Random(47);
    public static void main(String[] args) throws Exception {
        //字面常量获取方式获取Class对象
        Class initable = Initable.class;
        System.out.println("After creating Initable ref");
        //不触发类初始化
        System.out.println(Initable.staticFinal);
        //会触发类初始化
        System.out.println(Initable.staticFinal2);
        //会触发类初始化
        System.out.println(Initable2.staticNonFinal);
        //forName方法获取Class对象
        Class initable3 = Class.forName("com.it06.Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
    }
}/*
After creating Initable ref
47
Initializing Initable
258
Initializing Initable2
147
Initializing Initable3
After creating Initable3 ref
74
*/

从输出结果来看:

• 通过字面常量获取方式获取Initable类的Class对象并没有触发Initable类的初始化
• forName方法获取Class对象，肯定会触发初始化
• 同时发现调用Initable.staticFinal变量时也没有触发初始化，这是因为staticFinal属于编译期静态常量，在编译阶段通过常量传播优化的方式将Initable类的常量staticFinal存储到了一个称为NotInitialization类的常量池中，在以后对Initable类常量staticFinal的引用实际都转化为对NotInitialization类对自身常量池的引用，所以在编译期后，对编译期常量的引用都将在NotInitialization类的常量池获取，这也就是引用编译期静态常量不会触发Initable类初始化的重要原因
• 之后调用了Initable.staticFinal2变量后就触发了Initable类的初始化，注意staticFinal2虽然被static和final修饰，但其值在编译期并不能确定，因此staticFinal2并不是编译期常量，使用该变量必须先初始化Initable类

获取Class对象引用的三种方法	用法说明	初始化问题
getClass	Cookie cookie = new Cookie();Class B = cookie.getClass();	会触发类的初始化阶段
forName	Class A = Class.forName(“com.it06.Cookie”);	会触发类的初始化阶段
字面常量的方式”.class”	Class C = Cookie.class;	不会触发初始化

初始化是类加载的最后一个阶段，也就是说完成这个阶段后类也就加载到内存中(Class对象在加载阶段已被创建)，此时可以对类进行各种必要的操作了（如new对象，调用静态成员等），注意在这个阶段，才真正开始执行类中定义的Java程序代码或者字节码

3.2 泛化的Class对象引用

Class的引用总数指向某个类的Class对象，利用Class对象可以创建实例类，这也就足以说明Class引用表示的就是它指向的对象确切的类型

• Java SE5引入泛型后，使用我们可以利用泛型来表示Class对象更具体的类型
• 为什么不直接使用Class还要使用Class<?>呢？这样做的好处是告诉编译器，**我们是确实是采用任意类型的泛型，而非忘记使用泛型约束**，因此Class<?>总是优于直接使用Class，至少前者在编译器检查时不会产生警告信息。
  当然我们还可以使用extends关键字告诉编译器接收某个类型的子类

//编译通过！
Class<? extends Number> clazz = Integer.class;
//赋予其他类型
clazz = double.class;
clazz = Number.class;

四、类型转换问题

在Java中，所有类型转换都是在运行时进行正确性检查的，利用RRTI进行判断类型是否正确从而确保强制转换的完成，如果类型转换失败，将会抛出类型转换异常。

• 除了强制类型转换外，在Java SE5中新增一种使用Class对象进行类型转换的方式

Animal animal= new Dog();
//这两句等同于Dog dog = (Dog) animal;
Class<Dog> dogType = Dog.class;
Dog dog = dogType.cast(animal)

五、instanceof 关键字与isInstance方法

• instanceof 关键字，它返回一个boolean类型的值，意在告诉我们对象是不是某个特定的类型实例
• isInstance方法，则是Class类中的一个Native方法,与instanceof 效果相同

Object obj = new Animal();
//instanceof关键字 判断这个对象是不是这种类型
System.out.println(obj instanceof Animal); //true
//isInstance方法 判断这个对象能不能被转化为这个类
System.out.println(Animal.class.isInstance(obj)); //true

六、反射机制:运行时类的信息

在运行状态中

• 对于任意一个类，都能够知道这个类的所有属性和方法；
• 对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制

转载自大佬博客