类加载机制-初始化

    初始化是类加载中最后的一个阶段,也是与我们敲代码关系最大的一个阶段,所以我特意提了一个章节出来说这个问题.我想很多2B老湿经常会拿这个来考学生,看最后打印的值是什么..一般我看到这种题目就觉得恶心,但是我这次还是决定踩这坨屎...

    初始化的部分我想分为两个部分

    (1)虚拟机什么时候会对类做初始化

    (2)继承关系类按照什么顺序进行初始化

 

虚拟机什么时候会对类做初始化

类在什么情况下被加载,虚拟机的规范中并没有明确的规定 ,但是,类的初始化却明确规定了:有且只有四种情况必须立即对类进行初始化.

(1) 遇到new ,getstatic ,putstatic ,invokestatic 这4个字节码的时候必须对类进行初始化.new 表示在代码中显示的用new关键字创建对象.getstatic 和 putstatic表示读取和设置某个类的静态字段.invokestatic 表示初始化某个类的静态方法.

(2)使用java.lang.reflect包的方法对类进行反射调用的时候,必须先初始化

(3) 初始化某个类的时候,如果其父类没有初始化,则必须先初始化父类.

(4)包含main方法的类,虚拟机会先初始化.

   

除了上面说的4中情况,其他任何情况都不会初始化类.下面可以看几个不被初始化的情况.

 

通过子类引用父类的静态字段,不会导致子类初始化

package com.taobao.initialization;

public class InitializationClass {

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

}
class SuperClass {
	static {
		System.out.println("super class ini!");
	}
	public static String str = "str";
}
class SubClass extends SuperClass{
	static {
		System.out.println("sub class ini!");
	}
}

 运行结果为

 

通过创建对象数组,并不会类初始化

package com.taobao.initialization;

public class InitializationClass2 {

	public static void main(String[] args) {
		MyClass[] classes = new MyClass[10];
	}

}
class MyClass {
	static {
		System.out.println("my class init!");
	}
	public static String str = "str";
}

 

运行结果为 无任何输出.

 

引用其他类的常量,不会造成该类的初始化

package com.taobao.initialization;

public class InitializationClass3 {

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

}
class ConstClass {
	static {
		System.out.println("consts class init!");
	}
	public static final String str = "str";
}

 运行结果为

 这里需要说明的是 

写道

ConstClass类中的常量str,在编译阶段已经把此常量放到了InitializationClass3类中自己的常量池中了.也就是说,其实InitializationClass3类中并没有ConstClass类的引用了.

 

 

继承关系类之间按照什么顺序进行初始化

  

    程序员最关心的,无非是初始化的过程中执行了哪几行代码,而哪些没有 被执行,对应的执行顺序是怎么样的.我大概总结了一下无非是如下几点

(1)先静态变量赋值,然后再执行静态语句快(static语句块).正因为如此所以在static语句块中是可以访问类变量的.

(2)虚拟机保证了在子类的static语句快(或者说<clinit>)执行之前,父类的<clint>已经执行完毕.所以第一次被执行的<clinit>方法对应对应于java.lang.Object

(3)父类的<clinit>方法优先于子类的赋值操作

(4)<clinit>方法对于类或者接口来说不是必须的.一般来说如果这个类没有静态语句块,也没有对变量的赋值操作,那么就不会有<clinit>方法 

(5)<clinit>方法默认是加锁的.也就是说,如果多线程同时去初始化某个类,那么<clinit>方法是有同步状态的.前一个类没有初始化好的时候,后面的线程会等待.鉴于如此,尽量少在<clinit>方法(大部分是static{}语句块)中放耗时很多的操作.

 

下面是对应的例子

(1)

public class Foo {
    public static String str = "hello";

    static {
        //先静态变量赋值,然后再执行静态语句快(static语句块).正因为如此所以在static语句块中是可以访问类变量的.
        System.out.println(str);
    }

    public static void main(String [] args){
       
    }
}

 

 最后输出

写道

hello

 (2) 

public class Foo extends Bar {
    public static String str = "hello";

    static {
        System.out.println(str);
    }

    public static void main(String [] args){

    }
}

class Bar {
    static {
        //虚拟机保证了在子类的static语句快(或者说<clinit>)执行之前,父类的<clint>已经执行完毕.
        System.out.println("bar init");
    }
}

 输出

写道

bar init
hello

(3)

public class Foo extends Bar {
    public static int F_LENGTH = LENGTH;

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

    }
}

class Bar {
    public static int LENGTH = 2012;

    static {
        //父类的<clinit>方法优先于子类的赋值操作
        LENGTH = 2013;
    }
}

 输出为

写道

2013

 (4)这个直接看一下对应类的javap输出就OK

 (5)

public class Foo{


    static {
        //<clinit>方法默认是加锁的.也就是说,如果多线程同时去初始化某个类,那么<clinit>方法是有同步状态的.前一个类没有初始化好的时候,后面的线程会等待.
        if(true){
            System.out.println("Foo init.....";
            while (true){

            }
        }
    }
    public static void main(String [] args){
        Foo f1 = new Foo();
        Foo f2 = new Foo();
    }
}

 输出为

写道

Foo init....

 

 

    最后补充一点是,学校的很多老湿出题的时候老喜欢把这个类的初始化与构造函数的调用放一起出题,来做混淆.也就是说,<clinit>与<init>的混淆.. 简单一点说,就是先加载,再创建对象(或者说先<clinit>,再<init>).至于说<init>方法之间的重载之类的内容,由于本片文章里说的是类的初始化过程,并不是说创建对象的过程.所以这里就不深入说了.嘿嘿.这个可以参照我N早前整理的文章 

Java方法分派