Java 反射 Class对象

Java 反射 Class对象

@author ixenos

关键字：RTTI、动态绑定、动态加载、获得Class引用、泛型Class引用、newInstance的坑、JVM中的泛型类型信息

RTTI和动态绑定

---

RTTI即运行时类型识别 Run-Time Type Identification 或 Run-Time Type Information

例如，当把Shape对象放入List<Shape>的数组时会向上转型，但在向上转型为Shape的时候也会丢失Shape对象的具体类型，对于数组而言，他们只是Shape对象。从List<Shape>数组中取出元素时，这种容器（实际上它将所有元素当作Object持有）会自动将结果转型回Shape，这是RTTI最基本的使用形式，因为在Java中所有的类型转换都是在运行时进行正确性检查的，而这也是RTTI名字的含义：在运行时，识别一个对象的类型。

　此例中RTTI类型转换并不彻底，这是因为目前我们只知道这个List<Shape>保存的都是Shape，这在编译时由容器和泛型系统来保证，在运行时由类型转换操作来保证

　而类型转换后就是之前写的多态(动态绑定)的事情了，因为这时候需要调用对象的方法，动态绑定确定域和方法的调用

总结：RTTI在运行时识别一个对象的类型，之后多态在运行时判断对象的实际类型来确定调用

Class对象和动态加载

---

要理解RTTI在Java中的工作原理，必须先知道类型信息在运行时是如何表示的，而这项工作由Class对象完成

Class对象就是用来创建类的所有的常规对象的，每个类都有一个Class对象，每当编译了一个新类就会产生一个Class对象（被保存在一个.class文件中），如下图所示：

 

1.类加载器子系统：

为了生成类的对象，JVM使用类加载器子系统(Classloader)来加载.class文件（内容是字节码）

类加载器链：该子系统通常可以包含一条类加载器链，但只有一个原生类加载器，它（指子系统）是JVM实现的一部分

原生类加载器：原生类加载器加载的是所谓的可信类，他们通常从本地盘加载的(包括Java API类)

额外的类加载器：在这条链中通常不需要添加额外的类加载器，但如果由特殊要求（以某种特殊的方式加载类，以支持Web服务器应用，或者在网络中下载类）

2.动态加载：

所有类(XXX.class)都是在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态对象成员的引用时，就会加载这个类（比如调用静态方法、静态域）　

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 main(String[] args){
        System.out.println("main");
        new Candy();
        System.out.println("After creating Candy");
        try{
            Class.forName("Gum");
        }catch(ClassNotFoundException e){
            System.out.println("Gum not founded");
        }
        System.out.println("After creating Gum");
        new Cookie();
        System.out.println("After creating Cookie");
    }
}

----------------------------------
输出：
main
Loading Candy
After creating Candy
Loading Gum
After creating Gum
Loading Cookie
After creating Cookie

从输出看出：Class对象仅在需要的时候才被加载，static初始化是在类加载时进行的

对Class.forName()的调用结果说明：如果类Gum还没被加载就加载它，那么在加载的过程中，Gum的static子句被执行

而当只是由构造器构造对象时，类就加载，这说明了构造器也是类的静态方法，虽然没有static关键字修饰。因此，使用new 操作符创建类的新对象也会被当作对类的静态成员的引用

因此，Java程序（包含很多类）在它开始运行之前并非被完全加载，其各个部分（.class）是在必需时才加载的

3.类加载器对于动态加载：

类加载器首先检查这个类的Class对象是否已经加载。

如果未加载，默认的类加载器由类型查找.class文件（例如某个额外的类加载器可能会在数据库中查找字节码（.class文件的内容））

如果已加载，则Class对象将接受验证，确保没被破坏且不包含不良代码（Java的安全防范措施）

　

4.一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象 

Class类获得Class对象的引用

---

 0.前言：

为了使用类而做的准备工作包括三个步骤：

1）加载：类加载器查找字节码（一般在classpath中找），从字节码创建一个Class对象

2）链接：验证字节码，为静态域（只是static修饰的域，不包含static final ）分配存储空间，解析此类对其他类的所有引用

3）初始化：若该类有超类，对其初始化，执行静态初始化器和静态初始化块。这是对类的初始化

-----------------------------

***static final int = 47 是编译期常量，不需要对类进行初始化就可以读取

***static final int = Random.nextInt(100)  是运行时常量，这种一般要在对象创建后才会运行，超过初始化的阶段了！

***static int = 47 是非常数的静态域，不是常量，更不是编译期常量，链接阶段只分配存储空间，初始化阶段才初始化

1.Class类的forName静态方法（自动初始化）

只知道对应类型名时，使用Class.forName(String name) 动态生成Class<String>对象，

2.Object类对象自带getClass方法（已经初始化）

持有对应类型对象的引用时，使用对象的getClass()（属于根类Object的一部分），如new Integer(1).getClass()将返回Integer.class，而此时的类型对象也必定是在运行中了，所以已经初始化

3.使用类字面常量（不会自动初始化）

例如 Fancy.class、String.class、Integer.TYPE

1）类字面常量应用于：普通类（包含包装类哟）、接口、数组、基本数据类型

***基本数据类型 使用标准字段TYPE，这是个指向基本数据类型的Class对象的引用

***例如int.class等价于Integer.TYPE，但是不等价于Integer.class

2）使用".class"来创建Class对象的引用时，不会自动地初始化该Class对象。

那为什么不会自动初始化呢？由补充内容可知初始化被延迟到了对静态(static)方法（构造器等同于隐式静态）或者非常数静态域（如static int a = 1）进行首次引用时（创建对象的时候就是首次引用）才执行，而引用类字面常量在运行时只是到了加载和链接的阶段

泛型化的Class引用

---

1.作用：

1）对Class引用所指向的Class对象的类型进行限定（也就是说类型参数表示的就是类的类型，比如Class<T> = T.class）

2）让编译器强制执行额外的类型检查

2.通配符：

而为了在使用泛化的Class引用时放松限制，使用通配符，这是Java泛型的一部分

1）Class<?>：优于平凡的Class，即使他们是等价的，Class<?>若使用了一个非具体的引用，编译器将警报

2）Class<? extends T>：为了创建一个限定为某种类型(或该类型的子类型)的Class引用，使用通配符与extends关键字结合创建一个范围

public class BoundClass{
    public static void main(String[] args){
        Class<? extends Number> bound = int.class;
        bound = double.class;  //可引用该Class对象
        bound = Number.class;　//可引用该Class对象
    }
}

3.Class的newInstance()方法：

1）普通类Class对象的newInstance方法，返回Object类型的对象

2）普通泛型类Class对象的newInstance方法，返回确切类型的对象

3）newInstance()的坑：如果手头的是超类，即通配符类型由super修饰<? super FancyToy>，返回Object类型的对象

　　因为编译器将只允许你声明的超类引用是“某个类，它是FancyToy的超类”，这种含糊性的定义，所以只能返回Object保证安全

Class<? super FancyToy> up = ftClass.getSuperclass();
//下面编译不通过:
//Class<Toy> up2 = ftClass.getSuperclass();

//只能返回Object
Object obj = up.newInsance();

　　编译不通过的是因为getSuperclass返回的是超类引用，而超类引用必须是个含糊的定义，由Class<? super T>接收

public Class<? super T> getSuperclass()

返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。如果此 Class 表示 Object 类、一个接口、一个基本类型或 void，则返回 null。如果此对象表示一个数组类，则返回表示该 Object 类的 Class 对象。 

返回：

此对象所表示的类的超类。

4.JVM中的泛型类型信息

1.类型擦除后的类依然保留着一些泛型的微弱信息（但不知道类型参数传入了啥）。

例如，原始的Pair类知道源于泛型类Pair<T>，但无法知道是源于Pair<String>构造的还是Pair<Employee>构造的

2.Type接口

如同public static <T extends Comparable<? super T>> T min(T[] a) 这浑身上下的泛型都要被原始类型(raw type)替换，但JDK 5开始提供了一个接口Type，包含了描述泛型类型信息的方法

此接口包含以下子类型：

Class类，描述具体类型

TypeVariable类，描述类型变量　　<T extends Comparable<? super T>>

WildcardType类，描述通配符　　? super T

ParameterizedType类，描述泛型类或接口类型　　Comparable<? super T>

GenericArrayTyppe类，描述泛型数组　　T[]