类的初始化
在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。
在程序中，静态变量的初始化有两种途径：
1.在静态变量的声明处进行初始化；
2.在静态代码块中进行初始化。
没有经过显式初始化的静态变量将原有的值。
一个比较奇怪的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
package com.mengdd.classloader;
class Singleton {
// private static Singleton mInstance = new Singleton();// 位置1
// 位置1输出：
// counter1: 1
// counter2: 0
public static int counter1;
public static int counter2 = 0;
private static Singleton mInstance = new Singleton();// 位置2
// 位置2输出：
// counter1: 1
// counter2: 1
private Singleton() {
counter1++;
counter2++;
}
public static Singleton getInstantce() {
return mInstance;
}
}
public class Test1 {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstantce();
System.out.println("counter1: " + Singleton.counter1);
System.out.println("counter2: " + Singleton.counter2);
}
}
|
可见将生成对象的语句放在两个位置，输出是不一样的(相应位置的输出已在程序注释中标明)。
这是因为初始化语句是按照顺序来执行的。
静态变量的声明语句，以及静态代码块都被看做类的初始化语句，Java虚拟机会按照初始化语句在类文件中的先后顺序来依次执行它们。
类的初始化步骤
1.假如这个类还没有被加载和连接，那就先进行加载和连接。
2.假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类。
3.假如类中存在初始化语句，那就依次执行这些初始化语句。
类的初始化时机
Java程序对类的使用方式可以分为两种：
1.主动使用
2.被动使用
所有的Java虚拟机实现必须在每个类或接口被Java程序首次主动使用时才初始化它们。
主动使用的六种情况：
1.创建类的实例。
|
1
2
|
new Test();
|
2.访问某个类或接口的静态变量，或者对该静态变量赋值。
|
1
2
|
int b = Test.a;
Test.a = b;
|
3.调用类的静态方法
|
1
|
Test.doSomething();
|
4.反射
|
1
|
Class.forName(“com.mengdd.Test”);
|
5.初始化一个类的子类
|
1
2
3
4
5
6
|
class Parent{
}
class Child extends Parent{
public static int a = 3;
}
Child.a = 4;
|
6.Java虚拟机启动时被标明为启动类的类
|
1
|
java com.mengdd.Test
|
除了以上六种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。
接口的特殊性
当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
在初始化一个类时，并不会先初始化它所实现的接口。
在初始化一个接口时，并不会先初始化它的父接口。
因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。
final类型的静态变量
final类型的静态变量是编译时常量还是变量，会影响初始化语句块的执行。
如果一个静态变量的值是一个编译时的常量，就不会对类型进行初始化(类的static块不执行)；
如果一个静态变量的值是一个非编译时的常量，即只有运行时会有确定的初始化值，则就会对这个类型进行初始化(类的static块执行)。
例子代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
package com.mengdd.classloader;
import java.util.Random;
class FinalTest1 {
public static final int x = 6 / 3; // 编译时期已经可知其值为2，是常量
// 类型不需要进行初始化
static {
System.out.println("static block in FinalTest1");
// 此段语句不会被执行，即无输出
}
}
class FinalTest2 {
public static final int x = new Random().nextInt(100);// 只有运行时才能得到值
static {
System.out.println("static block in FinalTest2");
// 会进行类的初始化，即静态语句块会执行，有输出
}
}
public class InitTest {
public static void main(String[] args) {
System.out.println("FinalTest1: " + FinalTest1.x);
System.out.println("FinalTest2: " + FinalTest2.x);
}
}
|
主动使用的归属明确性
只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package com.mengdd.classloader;
class Parent {
static int a = 3;
static {
System.out.println("Parent static block");
}
static void doSomething() {
System.out.println("do something");
}
}
class Child extends Parent {
static {
System.out.println("Child static block");
}
}
public class ParentTest {
public static void main(String[] args) {
System.out.println("Child.a: " + Child.a);
Child.doSomething();
// Child类的静态代码块没有执行，说明Child类没有初始化
// 这是因为主动使用的变量和方法都是定义在Parent类中的
}
}
|
ClassLoader类
调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package com.mengdd.classloader;
class CL {
static {
System.out.println("static block in CL");
}
}
public class ClassLoaderInitTest {
public static void main(String[] args) throws Exception {
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> clazz = loader.loadClass("com.mengdd.classloader.CL");
// loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化
System.out.println("----------------");
clazz = Class.forName("com.mengdd.classloader.CL");
}
}
|
类加载器的父委托机制
类加载器
类加载器用来把类加载到Java虚拟机中。
类加载器的类型
有两种类型的类加载器：
1.JVM自带的加载器：
根类加载器(Bootstrap)
扩展类加载器(Extension)
系统类加载器(System)
2.用户自定义的类加载器：
java.lang.ClassLoader的子类，用户可以定制类的加载方式。
JVM自带的加载器
Java虚拟机自带了以下几种加载器。
1.根(Bootstrap)类加载器：
该加载器没有父加载器。
它负责加载虚拟机的核心类库，如java.lang.*等。
根类加载器从系统属性sun.boot.class.path所指定的目录中加载类库。
根类加载器的实现依赖于底层操作系统，属于虚拟机的实现的一部分，它并没有继承java.lang.ClassLoader类，它是用C++写的。
2.扩展(Extension)类加载器：
它的父加载器为根类加载器。
它从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK的安装目录的jre\lib\ext子目录(扩展目录)下加载类库，如果把用户创建的JAR文件放在这个目录下，也会自动由扩展类加载器加载。
扩展类加载器是纯Java类，是java.lang.ClassLoader类的子类。
3.系统(System)类加载器：
也称为应用类加载器，它的父加载器为扩展类加载器。
它从环境变量classpath或者系统属性java.class.path所指定的目录中加载类，它是用户自定义的类加载器的默认父加载器。
系统类加载器是纯Java类，是java.lang.ClassLoader类的子类。
注意：这里的父加载器概念并不是指类的继承关系，子加载器不一定继承了父加载器（其实是组合的关系）。
用户自定义类加载器
除了以上虚拟机自带的类加载器以外，用户还可以定制自己的类加载器(User-defined Class Loader)。
Java提供了抽象类java.lang.ClassLoader，所有用户自定义的类加载器都应该继承ClassLoader类。
类加载的父委托机制
从JDK 1.2版本开始，类的加载过程采用父亲委托机制，这种机制能更好地保证Java平台的安全。
在父委托机制中，除了Java虚拟机自带的根类加载器以外，其余的类加载器都有且只有一个父加载器，各个加载器按照父子关系形成了树形结构。
当Java程序请求加载器loader1加载Sample类时，loader1首先委托自己的父加载器去加载Sample类，若父加载器能加载，则由父加载器完成加载任务，否则才由loader1本身加载Sample类。
说明具体过程的一个例子：
loader2首先从自己的命名空间中查找Sample类是否已经被加载，如果已经加载，就直接返回代表Sample类的Class对象的引用。
如果Sample类还没有被加载，loader2首先请求loader1代为加载，loader1再请求系统类加载器代为加载，系统类加载器再请求扩展类加载器代为加载，扩展类加载器再请求根类加载器代为加载。
若根类加载器和扩展类加载器都不能加载，则系统类加载器尝试加载，若能加载成功，则将Sample类所对应的Class对象的引用返回给loader1，loader1再返回给loader2，从而成功将Sample类加载进虚拟机。
若系统加载器不能加载Sample类，则loader1尝试加载Sample类，若loader1也不能成功加载，则loader2尝试加载。
若所有的父加载器及loader2本身都不能加载，则抛出ClassNotFoundException异常。
总结下来就是：
每个加载器都优先尝试用父类加载，若父类不能加载则自己尝试加载；若成功则返回Class对象给子类，若失败则告诉子类让子类自己加载。所有都失败则抛出异常。
定义类加载器和初始类加载器
若有一个类加载器能成功加载Sample类，那么这个类加载器被称为定义类加载器。
所有能成功返回Class对象的引用的类加载器(包括定义类加载器，即包括定义类加载器和它下面的所有子加载器)都被称为初始类加载器。
假设loader1实际加载了Sample类，则loader1为Sample类的定义类加载器，loader2和loader1为Sample类的初始类加载器。
父子关系
需要指出的是，加载器之间的父子关系实际上指的是加载器对象之间的包装关系，而不是类之间的继承关系。
一对父子加载器可能是同一个加载器类的两个实例，也可能不是。
在子加载器对象中包装了一个父加载器对象。
例如loader1和loader2都是MyClassLoader类的实例，并且loader2包装了loader1，loader1是loader2的父加载器。
当生成一个自定义的类加载器实例时，如果没有指定它的父加载器(ClassLoader构造方法无参数)，那么系统类加载器就将成为该类加载器的父加载器。
父委托机制优点
父亲委托机制的优点是能够提高软件系统的安全性。
因为在此机制下，用户自定义的类加载器不可能加载应该由父加载器加载的可靠类，从而防止不可靠甚至恶意的代码代替由父加载器加载的可靠代码。
例如，java.lang.Object类总是由根类加载器加载，其他任何用户自定义的类加载器都不可能加载含有恶意代码的java.lang.Object类。
命名空间
每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成。
在同一个命名空间中，不会出现类的完整名字(包括类的包名)相同的两个类。
在不同的命名空间中，有可能会出现类的完整名字(包括类的包名)相同的两个类。
运行时包
由同一类加载器加载的属于相同包的类组成了运行时包。
决定两个类是不是属于同一个运行时包，不仅要看它们的包名是否相同，还要看定义类加载器是否相同。
只有属于同一运行时包的类才能互相访问包可见(即默认访问级别)的类和类成员。
这样的限制能避免用户自定义的类冒充核心类库的类，去访问核心类库的包可见成员。
假设用户自己定义了一个类java.lang.Spy，并由用户自定义的类加载器加载，由于java.lang.Spy和核心类库java.lang.*由不同的类加载器加载，它们属于不同的运行时包，所以java.lang.Spy不能访问核心类库java.lang包中的包可见成员。