java类的初始化（二）

类在初始化之前包括两个过程，分别为加载和连接，如下图：

1、加载：查找并加载类的二进制数据 

2、连接 

    –验证：确保被加载的类的正确性 

    –准备：为类的静态变量分配内存，并将其初始化为默认值 

    –解析：把类中的符号引用转换为直接引用 

3、初始化：为类的静态变量赋予正确的初始值 

     从上边我们可以看出类的静态变量赋了两回值。这是为什么呢？原因是，在连接过程中时为静态变量赋值为默认值，也就是说，只要是你定义了静态变量，不管你开始给没给它设置，我系统都为他初始化一个默认值。到了初始化过程，系统就检查是否用户定义静态变量时有没有给设置初始化值，如果有就把静态变量设置为用户自己设置的初始化值，如果没有还是让静态变量为初始化值

 

类的初始化

　　在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。

　　在程序中，静态变量的初始化有两种途径：

　　1.在静态变量的声明处进行初始化；

　　2.在静态代码块中进行初始化。

　　没有经过显式初始化的静态变量将原有的值。

类的初始化时机

　　Java程序对类的使用方式可以分为两种：

　　1.主动使用

　　2.被动使用

　　所有的Java虚拟机实现必须在每个类或接口被Java程序首次主动使用时才初始化它们。

 

　　主动使用的六种情况：

　　1.创建类的实例。

new Test();

　　

　　2.访问某个类或接口的静态变量，或者对该静态变量赋值。

int b =

Test.a;

Test.a

= b;

　　

　　3.调用类的静态方法

Test.doSomething();

　　

　　4.反射

Class.forName(“com.mengdd.Test”);

　　

　　5.初始化一个类的子类

class

Parent{

}

class Child  extends

Parent{

 

public  static  int a = 3

;

}

Child.a

= 4;

　　

　　6.Java虚拟机启动时被标明为启动类的类

java com.mengdd.Test

 

 　　除了以上六种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

 

来个“曹胜欢”博客中的例子：

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

	/*public  int counter1;
	public  int counter2 = 0;*/
	private Singleton()
	{
		counter1++;
		counter2++;
	}

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

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

输出结果为：

counter1 = 1
counter2 = 0

没想到吧，可能大部分人都会写下counter1 = 1  counter2 = 1这个结果，包括我。那么我们来看下这个程序的流程：

进入main()方法，进而调用静态方法getInstantce()，此时，触发了“主动使用Singleton类”会导致类的初始化。

首先，进行加载，然后连接，在连接的过程中对静态变量赋默认值，此时

Singleton=null

counter1 = 0

counter2 = 0

进而进行初始化，在初始化过程中按顺序来，首先给Singleton赋值，给它赋值，就要执行它的构造方法，然后执行counter1++;counter2++;所以这里的counter1 = 1;counter2 = 1;然后给counter2赋值0，此时counter2的值改变为0了，初始化后就执行输出操作了。（此时你可以尝试把counter1和counter2的final去掉，看看有什么变化）。

类的初始化步骤

　　1.假如这个类还没有被加载和连接，那就先进行加载和连接。

　　2.假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类。

　　3.假如类中存在初始化语句，那就依次执行这些初始化语句。

 

接口的特殊性

　　当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。

　　　　在初始化一个类时，并不会先初始化它所实现的接口。

　　　　在初始化一个接口时，并不会先初始化它的父接口。

　　因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。

 

final类型的静态变量

　　final类型的静态变量是编译时常量还是变量，会影响初始化语句块的执行。

　　如果一个静态变量的值是一个编译时的常量，就不会对类型进行初始化(类的static块不执行)；

　　如果一个静态变量的值是一个非编译时的常量，即只有运行时会有确定的初始化值，则就会对这个类型进行初始化(类的static块执行)。

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);
    }
}

结果为：

FinalTest1: 2
static block in FinalTest2
FinalTest2: 66

主动使用的归属明确性

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

 

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类中的
    }
}

结果为：

Parent static block
Child.a: 3
do something

ClassLoader类

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

 

package com.lxl.beautyOfPrograming;


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.lxl.beautyOfPrograming.CL");
        // loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化

        System.out.println("----------------");
        clazz = Class.forName("com.lxl.beautyOfPrograming.CL");
    }

}

输出结果为：

----------------
static block in CL