ClassLoader（类加载器）
1、Java虚拟机与程序的生命周期
在如下几种情况下，Java虚拟机将结束生命周期
–执行了System.exit()方法
–程序正常执行结束
–程序在执行过程中遇到了异常或错误而异常终止
–由于操作系统出现错误而导致Java虚拟机进程终止
2、类的加载、连接与初始化
1）加载：查找并加载类的二进制数据
2）连接：又分为三步
–验证：确保被加载的类的正确性（为了防止这样的情况：如果.class不是经过javac产生，而是恶意用户自己产生）
–准备：为类的静态变量分配内存，并将其初始化为默认值（为何是为静态变量分配内存，因为静态变量属于类，而其他实例变量还没生成，因为还没生成对象）
–解析：把类中的符号引用转换为直接引用
3）初始化：为类的静态变量赋予正确的初始值
public class Test
{ private static int a = 3;}
这里要特别注意：连接的第二步准备阶段是为静态变量分配内存，并初始化为默认值（默认值很关键），如上面的例子，在这一步就是先为a分配空间，然后将其值设为0；
在初始化阶段，为静态变量赋初始值，就是a设为3，所以a经过了两次赋值，一次为0（默认值），一次为3（初始值）。
上例还可以这样写：
public class Test
{ private static int a;
static { a = 3; }
}
3、Java程序对类的使用方式可分为两种
–主动使用
–被动使用
所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化他们
主动使用（六种）
–创建类的实例
–访问某个类或接口的静态变量，或者对该静态变量赋值
–调用类的静态方法
–反射（如Class.forName(“com.study.Test”)）
–初始化一个类的子类
–Java虚拟机启动时被标明为启动类的类（Java Test）
除了以上六种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化
4、类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构
加载.class文件的方式
–从本地系统中直接加载
–通过网络下载.class文件
–从zip，jar等归档文件中加载.class文件
–从专有数据库中提取.class文件
–将Java源文件动态编译为.class文件
类的加载的最终产品是位于堆区中的Class对象
Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口(全都是反射接口)
5、有两种类型的类加载器
–Java虚拟机自带的加载器
•根类加载器（Bootstrap）（c++代码编写，无法获取）
•扩展类加载器（Extension）（java代码实现）
•系统类加载器（System）——应用加载器（java代码实现）
–用户自定义的类加载器
•java.lang.ClassLoader的子类
•用户可以定制类的加载方式
6、类加载器并不需要等到某个类被“首次主动使用”时再加载它
JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误（LinkageError错误）； 如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误
（如果使用jdk1.6编译的class文件，在jdk1.5环境下使用，可能出现LinkageError错误）
7、类的验证：类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。
类的验证的内容
–类文件的结构检查
–语义检查
–字节码验证
–二进制兼容性的验证
类的验证主要包括以下内容：
类文件的结构检查：确保类文件遵从Java类文件的固定格式
语义检查：确保类本身符合Java语言的语法规定，比如验证final类型的类有没有子类，以及final类型的方法没有被覆盖。
字节码验证：确保字节码流可以被Java虚拟机安全地执行。字节码流代表Java方法（包括静态方法和实例方法）。它是由被称为操作码的单字节指令组成的序列，每一个操作码后都跟着一个或多个操作数。字节码验证步骤会检查每个操作码是否合法，即是否有着合法的操作数。
二进制兼容的验证：确保互相引用的类之间协调一致。例如在Worker类的gotoWork（）方法中会调用Car类的run（）方法。Java虚拟机在验证Worker类时，会检查在方法区内是否存在Car类的run（）方法，假如不存在（当Worker类和Car类的版本不兼容，就会出现这种问题），就会抛出NoSuchMethodError错误。
8、类的准备：在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值。例如对于以下Sample类，在准备阶段，将为int类型的静态变量a分配4个字节的内存空间，并且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0.
public class Sample
{
private static int a = 1;
public static long b;
static
{
b = 2;
}
......
}
9、类的解析：在解析阶段，Java虚拟机会把类的二进制数据中的符号引用替换为直接引用。例如在Worker类的gotoWork（）方法中会引用Car类的run（）方法
public void gotoWork()
{
car.run(); //这段代码在Worker类的二进制数据中表示为符号引用
}
在Worker类的二进制数据中，包含了一个对Car类的run（）方法的符号引用，它由run（）方法的全名和相关描述符组成，在解释阶段，Java虚拟机会把这个符号引用替换为一个指针，该指针指向Car类的run（）方法在方法区的内存位置，这个指针就是直接引用。
10、类的初始化：在类的初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量的初始化有两种途径：（1）在静态变量的声明处初始化；（2）在静态代码块中进行初始化。例如在以下代码中，静态变量a和b都被显式初始化，而静态变量c没有被显式初始化，它将保持默认值0.
public class Sample
{
private static int a = 1;
public static long b;
public static long c;
static
{
b = 2;
}
......
}
静态变量的声明语句，以及静态代码代码块都被看做类的初始化语句，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
}
}
11、一个反映类加载与初始化的例子：
class Singleton
{
private static Singleton singleton = new Singleton(); //位置1
public static int counter1;
public static int counter2 = 0;
// private static Singleton singleton = new Singleton(); //位置2
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);
}
}
对于上例，使用位置1处的语句，打印结果为：counter1 = 1 counter2 = 0
注释掉位置1，启用位置2处语句，打印结果：counter1 = 1 counter2 = 1
分析：main方法中执行Singleton singleton = Singleton.getInstance();时，属于对Singleton类的主动使用，类被加载，然后进入连接阶段，在连接的准备阶段，为类的静态变量分配内存空间，并赋予默认值，所以这时静态变量singleton=null，counter1 = 0，counter2 =0，因为引用变量默认值为null，int类型默认值为0，这里要特别注意的是counter2，他的0是默认值0。然后JVM继续执行，当进入到类的初始化阶段时，为类的静态变量赋予初始值，并且是按照语句的先后顺序，所以这时singleton
= new Singleton（），生成Singleton对象，生成对象调用构造方法，所以counter1 = 1 counter2 = 1，（上一步准备阶段都设置了默认值0），初始化完singleton后，按顺序在初始化counter1，因为counter1没有初始化语句，保持不变，这时应该还是1，接着初始化counter2，这里counter2进行了初始化，counter2 = 0，这个0是初始值，所以counter2又变为0，所以打印结果就为counter1 = 1 counter2 = 0。
如果将singleton的初始化语句位置变为位置2处，准备阶段状况同上，初始化时，先初始化counter1和counter2，counter1没有初始化语句，保持默认值0不变，counter2有初始化语句，初始值为0，赋给counter2，因为counter2的默认值也为0，初始值与默认值相同，保持0不变（值不变，但是动作是实实在在发生了），这时在初始化singleton，调用构造方法counter1和counter2都加1，所以打印结果就是counter1 = 1 counter2 = 1.
12、类的初始化步骤
1）假如这个类还没有被加载和连接，那就先进行加载和连接
2）假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类
3）假如类中存在初始化语句，那就依序执行这些初始化语句。
对于静态final类型的变量，如果其初始值是编译期能确定的，则在使用不会导致类的初始化，反之，如果其初始值是运行期才能确定的，则使用时会导致类的初始化：
class FinalTest
{
public static final int x = 6/3;
static
{
System.out.println("FinalTest static block");
}
}
public class Test2
{
public static void main(String[] args)
{
System.out.println(FinalTest.x);
}
}
import java.util.Random;
class FinalTest2
{
public static final int x = new Random().nextInt(100);
static
{
System.out.println("FinalTest static block");
}
}
public class Test3
{
public static void main(String[] args)
{
System.out.println(FinalTest2.x);
}
}
对于Test2，只打印 2 （即FinalTest没有执行类初始化）
对于Test3，则先打印FinalTest static block，再打印x的值。（FinalTest2执行了类初始化）
13、类的初始化时机
当java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口；在初始化一个类时，并不会先初始化它所实现的接口；在初始化一个接口时，并不会先初始化它的父接口。因此，一个父接口并不会因为它的子接口或实现类的初始化而初始化，只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。
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");
}
}
public class Test4
{
static
{
System.out.println("Test4 static block");
}
public static void main(String[] args)
{
System.out.println(Child.b);
}
}
结果为：
Test4 static block
Parent static block
Child static block
4
--------------------------------------------------------------------------
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");
}
}
public class Test5
{
static
{
System.out.println("Test5 static block");
}
public static void main(String[] args)
{
Parent2 parent;
System.out.println("-------");
parent = new Parent2();
System.out.println(Parent2.a);
System.out.println(Child2.b);
}
}
结果：
Test5 static block
-------
Parent2 static block
3
Child2 static block
4
Parent2 parent;这一句不是对类的主动使用，不会导致初始化，而System.out.println(Child2.b);是对Child2的主动使用，要初始化，因为其右继承了Parent2，先要对Parent2初始化，又因为System.out.println(Parent2.a);Parent2已经初始化，Parent2已存在，所以Child2只初始化自己。
程序中对子类的“主动使用”会导致父类的初始化；但对父类的“主动”使用并不会导致子类初始化（不可能说生成一个Object类的对象就导致系统中所有的子类都会被初始化）
只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用
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");
}
}
public class Test6
{
public static void main(String[] args)
{
System.out.println(Child3.a);
Child3.doSomething();
}
}
结果：
Parent3 static block
3
do something
这里Child3没有被初始化，因为a和doSomething方法都是父类的，基于上面的说明：只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用，所以这里不是对Child3的主动使用，没有初始化。
14、调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
package com.abc.classloader
class CL
{
static
{
System.out.println("class CL");
}
}
public class Test7
{
public static void main(String[] args) throws Exception
{
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> clazz = loader.loadClass("com.abc.classloader.CL");
System.out.println("--------");
clazz = Class.forName("com.abc.classloader.CL");
}
}
结果：
--------
class CL
这一句：Class<?> clazz = loader.loadClass("com.abc.classloader.CL");并没有导致CL类初始化，因为调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
15、