Java类加载

java虚拟机与程序的生命周期

在以下几种状况下，java虚拟机将结束生命周期

• 执行了System.exit()方法
• 程序正常执行结束
• 程序在执行过程当中遇到了异常或错误而异常终止
• 因为操做系统出现错误而致使java虚拟机进程终止

类的加载，链接与初始化

• 加载：查找并加载类的二进制数据
• 链接
  • 验证：保证被加载的类的正确性
  • 准备：为类的静态变量分配内存，并将其初始化为默认值
  • 解析：把类中的符号引用转换为直接引用
• 初始化：为类的静态变量赋予正确的初始值

java程序对类的使用方式可分为两种

• 主动使用
• 被动使用
  全部的java虚拟机实现必须在每一个类或接口被java程序“首次主动使用”时才初始化它们

主动使用（六种）

• 建立类的实例
• 访问某个类或接口的静态变量，或者对该静态变量赋值
• 调用类的静态方法
• 反射（如Class.forName("com.ak.test"))
• 初始化一个类的子类
• java虚拟机启动时被标明为启动类的类（java test）
  除了以上6种状况，其余使用java类的方式都被看做是对类的被动使用，都不会致使类的初始化

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区，而后在
堆区建立一个java.lang.Class对象，用来封装类在方法区内的数据结构

加载class文件的方式

• 从本地系统中直接加载
• 经过网络下载.class文件
• 从zip,jar等归档文件中加载.class文件
• 从专有数据库中提取.class文件
• 将java源文件动态编译为.class文件

类的加载的最终产品是位于堆区中的Class对象
Class对象封装了类在方法区内的数据结构，而且向java程序员提供了访问方法区内的数据结构的接口

类的加载

有两种类型的类加载器

• java虚拟机自带的加载器
  • 根类加载器（Bootstrap）
  • 扩展类加载器（Extension）
  • 系统类加载器（System）
• 用户自定义的类加载器
  • java.lang.ClassLoader的子类
  • 用户能够定制类的加载方式

public class ClassLoaderDemo {
    public static void main(String[] args) {
        ClassLoader loader =  ClassLoaderDemo.class.getClassLoader();
        while(loader!=null){
            System.out.println(loader.getClass().getName());
            loader = loader.getParent();
        }
        System.out.println(String.class.getClassLoader());
    }
}

• 类加载器并不须要等到某个类被“首次主动使用”时再加载它
• jvm规范容许类加载器在预料某个类将要被使用时就预先加载它，若是在预先加载的过程当中遇到了.class文件缺失或存在
  错误，类加载器必须在程序首次主动使用该类时才报告错误（LinkageError错误）
• 若是这个类一直没有被程序主动使用，那么类加载器就不会报告错误

类的验证

类被加载后，就进入链接阶段，链接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去
类的验证内容

• 类文件的结构检查
  确保类文件听从java类文件的固定格式
• 语义检查
  确保类自己符合java语言的语法规定，好比验证final类型的类没有子类，以及final类型的方法没有覆盖
• 字节码验证
  确保字节码流能够被java虚拟机安全的执行，字节码流表明java方法（包括静态方法和实例方法），它是由被称作操做码的单字节指令
  组成的序列，每个操做码后都跟着一个或多个操做数，字节码验证步骤会检查每一个操做码是否合法，便是否有着合法的操做数
• 二进制兼容性验证
  确保相互引用的类之间协调一致，例如在Worker类的gotoWork()方法中会调用Car类的run()方法，java虚拟机在验证Worker类时会
  检查在方法区内是否存在Car类的run()方法，假如不存在（当Worker类和Car类的版本不兼容，就会出现这种问题）会抛出NoSuchMethodError错误

类的准备

在准备阶段，java虚拟机为类的静态变量分配内存，并设置默认的初始值，例如对于Sample类，在准备阶段，将int类型的静态变量a分配4个字节的内存
空间，而且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，而且赋予默认值0

类的解析

在解析阶段，java虚拟机会把类的二进制数据中的符号引用替换为直接引用，例如在Worker类的gotoWork()方法中会引用Car类的run()方法
public void gotoWorker(){ car.run(); }
在Worker类的二进制数据中，包含了一个对Car类的run()方法的符号引用，它由run()方法的全名和相关描述符组成，在解析阶段，java虚拟机会把
这个符号引用替换为一个指针，该指针指向Car类的run()方法在方法区内的内存位置，这个指针就是直接引用

类的初始化

在初始化阶段，java虚拟机执行类的初始化语句，为类的静态变量赋予初始值，在程序中，静态变量的初始化有两种途径：

• 在静态变量的声明处进行初始化
• 在静态代码块中进行初始化
  例如如下代码中静态变量c没有被显式初始化，它将保持默认值0

public class Sample{
    private static int a = 1; // 在静态变量的声明处进行初始化
    public static long b;
    public static long c;

    static{ b = 2; } // 在静态代码块中进行初始化
}

class Singleton {
    //private static Singleton singleton = new Singleton();
    // counter1=1 counter2=0
    public static int counter1;
    public static int counter2 = 0;
    private static Singleton singleton = new Singleton(); 
    // counter1=1 counter2=1

    private Singleton(){counter1++; counter2++;}

    public static Singleton getInstance(){return singleton;}
}

public class MyTest{
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1= " + singleton.counter1);
        System.out.println("counter2= " + singleton.counter2);
    }
}

静态变量的声明语句，以及静态代码块都被看作类的初始化语句，java虚拟机会按照初始化语句在类文件中的前后顺序来依次执行它们
例如当如下Sample类被初始化后它的静态变量a的取值为4

public class Sample{
    static int a = 1;
    static{ a = 2; }
    static{ a = 4; }
    public static void main(String[] args){ System.out.println("a= " + a)} // 打印a=4
}

类的初始化步骤

• 假如这个类尚未被加载和链接，那就先进行加载和链接
• 假如类存在直接的父类，而且这个父类尚未被初始化，那就先初始化直接的父类
• 假如类中存在初始化语句，那就依次执行这些初始化语句

class FinalTest{
    public static final int x = 6/3; 
    // 编译时肯定 不会致使类初始化
    // public static final int x = new Random().nextInt(100);       // 运行时变量 对类进行初始化
    static{
        System.out.println("FinalTest static block");
    }
}

public class Test2 {
    public static void main(String[] args) {
        System.out.println(FinalTest.x);
    }
}

当java虚拟机初始化一个类时，要求它的全部父类都已经被初始化，可是这条规则并不适用于接口
在初始化一个类时，并不会先初始化它所实现的接口
在初始化一个接口时，并不会先初始化它的父接口
所以，一个父接口并不会由于它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定接口的静态变量时才会致使接口初始化

public class Test3 {
    static{
        System.out.println("Test3 static block");
    }

    public static void main(String[] args) {
        System.out.println(Child.b);
    }
}

class Parent{
    static int a = 3;
    static{
        System.out.println("Parent static block");
    }
}

class Child extends Parent{
    static int b = 4;
    static{
        System.out.println("Child static block");
    }
}

输出：
Test3 static block
Parent static block
Child static block
4

public class Test4 {
    static{
        System.out.println("Test4 static block");
    }

    public static void main(String[] args) {
        Parent parent;
        System.out.println(Parent2.a);
        System.out.println(Child2.b);
    }
}

class Parent2{
    static int a = 3;
    static{
        System.out.println("Parent2 static block");
    }
}

class Child2 extends Parent2{
    static int b = 4;
    static{
        System.out.println("Child2 static block");
    }
}

输出：
Test4 static block
Parent2 static block
3
Child2 static block
4

对子类的主动使用会致使父类被初始化，但对父类的主动使用并不会致使子类初始化（不可能说生成一个Object类的对象致使全部子类初始化）

只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才能够认为是对类或接口的主动使用

public class Test5 {
    public static void main(String[] args) {
        System.out.println(Child3.a);
        Child3.doSomething();
    }
}

class Parent3{
    static int a = 3;
    static{
        System.out.println("Parent3 static block");
    }

    static void doSomething(){
        System.out.println("do something");
    }
}

class Child3 extends Parent3{
    static{
        System.out.println("Child3 static block");
    }
}

输出：
Parent3 static block
3
do something

调用ClassLoader类的loadClass方法加载一个类，并非对类的主动使用，不会致使类的初始化

public class Test6 {
    public static void main(String[] args) throws Exception{
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        loader.loadClass("com.ak.cls.C");
        System.out.println("line");
        Class.forName("com.ak.cls.C");
    }
}

class C{
    static{
        System.out.println("Class C");
    }
}

输出： line Class C