Java&Android 基础知识梳理(5) 类加载&对象实例化

1、概述

虚拟机的类加载机制定义：把描述类的数据从Class文件（一串二进制的字节流）加载到内存，并对数据进行校验、转换解析和初始化，最终造成被虚拟机直接使用的Java类型。

在Java语言里，类型的加载、链接和初始化过程都是在程序运行期间完成的，Java里天生能够动态扩展的语言特性就是依赖运行期动态加载和动态链接这个特色实现的。

用户能够经过Java预约义的和自定义类加载器，让一个本地的应用程序能够在运行时从网络或其余地方加载一个二进制流做为程序代码的一部分。

2、类加载的时机

2.1 类加载包含那些阶段

类从被加载到虚拟机内存中开始，到卸载出内存，所通过的生命周期有：

• 1.加载
• 2.验证
• 3.准备
• 4.解析
• 5.初始化
• 6.使用
• 7.卸载

其中2-4统称为链接，上面的过程有几个须要注意的点：

• 加载、验证、准备、初始化、卸载这五个阶段按顺序循序渐进地开始，在一个阶段执行的过程当中有可能调用、激活另一个阶段。
• 解析阶段有可能在初始化以后开始，这是为了支持Java语言的运行时绑定。

2.2 类加载触发的时机

有且仅有下面五种状况必须当即对类进行初始化：

• 第一种：遇到new/getstatic/putstatic/invokestatic这4条字节码指令时，若是类没有进行过初始化，则须要先触发其初始化，场景：
• 使用new关键字实例化对象
• 读取或设置一个类的静态字段（被final修饰，已在编译期把结果放入常量池的字段除外）
• 调用一个类的静态方法

//1.new关键字.
        LoadInvokeClass loadInvokeClass = new LoadInvokeClass();
        //2.访问静态变量
        int content = LoadInvokeClass.sContent;
        //3.调用静态方法.
        LoadInvokeClass.staticMethod();
复制代码

• 第二种：使用java.lang.reflect包的方法对类进行反射调用的时候，若是类没有进行过初始化，则须要先触发其初始化。

try {
            Class<?> mClass = Class.forName("com.example.lizejun.repojavalearn.load.LoadInvokeClass");
        } catch (Exception e) { e.printStackTrace(); }
复制代码

• 第三种：当初始化一个类的时候，若是须要初始化其父类，可是发现父类没有初始化、那么须要先触发其父类的初始化。

//其中LoadInvokeClass是LoadInvokeClassChild的父类.
        LoadInvokeClassChild classChild = new LoadInvokeClassChild();
复制代码

• 第四种：当虚拟机启动时，用户须要指定一个要执行的主类（包含main()方法），虚拟机会先初始化这个主类。
• 第五种：使用JDK 1.7的动态语言支持时，若是一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic/REF_putStatic/REF_invokeStatic的句柄方法，而且这个方法句柄所对应的类没有进行过初始化，则须要先触发其初始化。

2.3 被动引用

在2.2中谈到的都是主动引用，除此以外，全部引用类的方法都称为被动引用，而被动引用不会触发类的初始化：

• 类初始化时，若是父类没有被初始化，那么会先初始化父类，这一过程将一直递归到Object为止，可是不会去初始化它所实现的接口，即当咱们初始化ClassChild的时候，只会先初始化ClassParent，淡不会初始化ClassInterface。

public interface ClassInterface {}

public class ClassParent implements ClassInterface {
    static {
        System.out.println("load ClassParent");
    }
}

public class ClassChild extends ClassParent {
    static {
        System.out.println("load ClassChild");
    }
}
复制代码

• 接口初始化时，不要求父接口所有初始化，只有真正用到了父接口的时候（如引用接口中定义的常量），那么才会初始化。
• 当访问某个类的静态域时，不会触发父类的初始化或者子类的初始化，即便静态域被子类或子接口或者它的实现类所引用，咱们给ClassChild添加一个静态属性，访问这个静态属性不会初始化ClassParent。

public class ClassChild extends ClassParent {

    public static int sNumber;

    static {
        System.out.println("load ClassChild");
    }
}
复制代码

• 若是一个静态变量是编译时常量，则对它的引用不会引发定义它的类的初始化，以下面访问sNumber，那么不会引发ClassChild的实例化。

public class ClassChild extends ClassParent {

    public static final int sNumber = 2;

    static {
        System.out.println("load ClassChild");
    }
}
复制代码

• 经过数组定义来引用类，不会触发此类的初始化。

ClassChild[] children = new ClassChild[10];
复制代码

3、类加载的过程

3.1 加载

在"加载"阶段，虚拟机须要完成如下三件事情：

• 经过一个类的全限定名来获取定义此类的二进制字节流。
• 将这个字节流所表明的静态存储结构转化为方法区的运行时数据结构。
• 在内存中生成一个表明这个类的java.lang.Class对象，做为方法区这个类的各类数据的访问入口。

3.2 验证

"验证"阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，而且不会危害自身的安全，大体会完成下面四个阶段的校验动做：

• 文件格式验证
• 元数据验证
• 字节码验证
• 符号引用验证

3.3 准备

"准备"阶段是正式为类变量（被static修饰，而不是实例变量）分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。

• 对于static而且非final的类变量，将被初始化为数据类型的零值。
• 对于static且final的类变量，在这个阶段就会被初始化为ConstantValue属性所指定的值。

3.4 解析

“解析”阶段是虚拟机将常量池的符号引用替换为直接引用的过程，包括：

• 类或接口的解析
• 字段解析
• 类方法解析
• 接口方法解析

3.5 初始化

根据程序员经过程序指定的主观计划去初始化类变量和其它资源，也就是执行类构造器<clinit>()方法的过程：

• <clinit>方法是由编译器自动收集类中的全部类变量的赋值动做和静态语句块中的语句合并而成，顺序是由语句在源文件中出现的顺序决定的。静态语句块只能访问到定义在它以前的变量，对于定义在它后面的变量只能赋值不能访问。

• <clinit>()方法与类的构造函数不一样，它不须要显示地调用父类构造器，虚拟机会保证在子类的<clinit>()方法执行前，父类的<clinit>()方法已经执行完毕，所以在虚拟机中第一个杯知行的<clinit>()方法的类确定是java.lang.Object。

• 父类的静态语句块要优先于子类的变量赋值操做。

• 若是一个类中没有静态语句块，也没有对类变量的赋值操做，那么编译器能够不为这个类生成<clinit>()方法。

• 接口不能接口中仅有变量初始化的赋值操做，但执行接口的<clinit>()方法不须要先执行父接口的<clinit>()方法，只有当父接口中定义的变量使用时，父接口才会初始化，另外，接口的实现类在初始化时也同样不会执行接口的<clinit>()方法。

• 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步。

4、类加载器

4.1 概念

类加载器用来“经过一个类的全限定名来获取描述此类的二进制字节流”。

4.2 类与类加载器

类加载器用于实现类的加载动做，除此以外，任意一个类，都须要由它加载它的类加载器和这个类自己一同确立其在Java虚拟机中的惟一性。

每个类加载器，都拥有一个独立的类名称空间，比较两个类是否相等，只有在两个类由同一个类加载器加载的前提下才有意义。

相等表明类的Class对象的equals方法，isAssignableFrom方法，isInstance方法。

4.3 双亲委派模型

绝大部分Java程序都会用到如下三种系统提供的类加载器：

• 启动类加载器
• 扩展类加载器
• 应用类加载器

类加载器之间的层次关系，称为类加载器的双亲委派模型，这个模型要求除了顶层的启动类加载器外，其他的类都应当有本身的父类加载器，通常使用组合来复用父加载器的代码。

双亲委派模型的工做过程：若是一个类加载器收到了类加载的请求，它首先不会去尝试加载这个类，而是把这个请求委派给父类加载器去完成，只有当父类加载器反馈本身没法完成这个加载请求时，子加载器才会尝试本身加载。

5、对象实例化

在类加载过程完毕后，若是须要进行实例化对象就须要通过一下步骤，按优先加载父类，再到子类的顺序执行：

• 加载父类构造器
• 为父类实例对象分配存储空间并赋值
• 执行父类的初始化块
• 执行父类构造函数
• 加载子类加载器
• 为子类实例对象分配存储控件并赋值
• 执行子类的初始化块
• 执行子类构造函数

咱们用一个简单的例子： 其中ClassOther是一个单独的类：

public class ClassOther {

    public int mNumber;

    public ClassOther() {
        System.out.println("ClassOther Constructor");
    }

    public void setNumber(int number) {
        this.mNumber = number;
    }

    public int getNumber() {
        return mNumber;
    }
}
复制代码

ClassChild则继承于ClassChild：

public class ClassParent {

    {
        System.out.println("ClassParent before mClassParentContent");
    }

    private ClassOther mClassParentContent = new ClassOther(10);

    {
        System.out.println("ClassParent after mClassParentContent=" + mClassParentContent.mNumber);
    }

    public ClassParent(int number) {
        mClassParentContent.setNumber(number);
        System.out.println("ClassParent Constructor, mClassParentContent=" + mClassParentContent.mNumber);
    }


}

public class ClassChild extends ClassParent {

    {
        System.out.println("ClassChild before a");
    }

    private int mClassChildContent = 1;

    {
        System.out.println("ClassChild after mClassChildContent=" + mClassChildContent);
    }

    public ClassChild() {
        super(2);
        System.out.println("ClassChild Constructor");
    }
}
复制代码

当咱们实例化一个ClassChild对象时，调用的顺序以下：