java类加载机制浅析

由一道题目引发的关于类加载时执行顺序的思考

下面这道题乍一看很简单，但是运行结果也许并不是你想的那样

class Singleton {
    private static Singleton singleTon = new Singleton();
    public static int count1;
    public static int count2 = 0;
//  public static final int count3 = 0;


    private Singleton() {
        count1++;
        count2++;
        System.out.println(111);
    }

    public static Singleton getInstance() {
        return singleTon;
    }

}

public class Test {
    public static void main(String[] args) {
//      System.out.println(Singleton.count3);
        Singleton singleTon = Singleton.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}

错误答案：

count1=1

count2=1

正确答案：

count1=1

count2=0

why？

何时开始类的初始化？

什么情况下需要开始类加载过程的第一个阶段:”加载”。虚拟机规范中并没强行约束，这点可以交给虚拟机的的具体实现自由把握，但是对于初始化阶段虚拟机规范是严格规定了如下几种情况，如果类未初始化会对类进行初始化。

创建类的实例
访问类的静态变量(除常量【被final修辞的静态变量】原因:常量一种特殊的变量，因为编译器把他们当作值(value)而不是域(field)来对待。如果你的代码中用到了常变量(constant variable)，编译器并不会生成字节码来从对象中载入域的值，而是直接把这个值插入到字节码中。这是一种很有用的优化，但是如果你需要改变final域的值那么每一块用到那个域的代码都需要重新编译。)
访问类的静态方法
反射如(Class.forName(“my.xyz.Test”))
当初始化一个类时，发现其父类还未初始化，则先出发父类的初始化
虚拟机启动时，定义了main()方法的那个类先初始化

以上情况称为称对一个类进行“主动引用”，除此种情况之外，均不会触发类的初始化，称为“被动引用”

扫描二维码关注公众号，回复： 3220979 查看本文章

接口的加载过程与类的加载过程稍有不同。接口中不能使用static{}块。当一个接口在初始化时，并不要求其父接口全部都完成了初始化，只有真正在使用到父接口时（例如引用接口中定义的常量）才会初始化。

被动引用例子

子类调用父类的静态变量，子类不会被初始化。只有父类被初始化。。对于静态字段，只有直接定义这个字段的类才会被初始化.
通过数组定义来引用类，不会触发类的初始化
访问类的常量，不会初始化类


class SuperClass {
    static {
        System.out.println("superclass init");
    }
    public static int value = 123;
}

class SubClass extends SuperClass {
    static {
        System.out.println("subclass init");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(SubClass.value);// 被动应用1
        SubClass[] sca = new SubClass[10];// 被动引用2
    }
}

程序运行输出 superclass init

class ConstClass {
    static {
        System.out.println("ConstClass init");
    }
    public static final String HELLOWORLD = "hello world";
}

public class Test {
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLOWORLD);// 调用类常量
    }
}

程序输出结果

hello world

题目解析

class SingleTon {
    private static SingleTon singleTon = new SingleTon();
    public static int count1;
    public static int count2 = 0;

    private SingleTon() {
        count1++;
        count2++;
    }

    public static SingleTon getInstance() {
        return singleTon;
    }
}

public class Test {
    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}

分析：

1:SingleTon singleTon = SingleTon.getInstance();调用了类的SingleTon调用了类的静态方法，触发类的初始化

2:类加载的时候在准备过程中为类的静态变量分配内存并初始化默认值 singleton=null count1=0,count2=0

3:类初始化化，为类的静态变量赋值和执行静态代码快。singleton赋值为new SingleTon()调用类的构造方法

4:调用类的构造方法后count=1;count2=1

5:继续为count1与count2赋值,此时count1没有赋值操作,所有count1为1,但是count2执行赋值操作就变为0

静态代码块和静态变量的顺序

public class Demo{
          public static int i;
          static{
                i = 20;
                //这里的i， 是可以被用作运算的。
           }

}

这时候如果你在main函数输出i， 那么i=20；



public class Demo{  
          static{
                i = 20;
             //这里的i， 是不能被用作运算的， 因为本质上 i 还未被定义
           }
          public static int i;

}

这时候如果你在main函数输出i， 那么i=20；



 public class Demo{  
          static{
                i = 20;
             //这里的i， 是不能被用作运算的， 因为本质上 i 还未被定义
           }
          public static int i = 1;
}

//但是如果我们给静态的i附上一个初始值后，那么结果就变了。

这时候如果你在main函数输出i， 那么i=1；

总结： 静态变量和static修改的静态代码块运行的顺序是根据代码编写的先后，而且第二种写法毫无意义。为了避免出现不必要的麻烦，不管是否有在静态代码块中使用静态变量，都应当把静态变量写在静态代码块的上方。

静态代码块和局部代码块

public class test1 {  

    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        new test1();  
        new test1();  
    }  

    {  
        System.out.println("2");  
    }  
    static {  
        System.out.println("3");  
    }  

    public test1(){  
        System.out.println("1");  
    }  

}

输出结果为:

3
2
1
2
1

总结：从结果中发现静态代码块以及非静态代码块都会在构造函数前执行，首次访问时，静态代码块会在非静态代码块前执行

静态代码块是在类加载时自动执行的，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块

静态代码块只会执行一次，非静态代码块可以执行多次