学习笔记-JAVA中静态块、静态变量加载顺序详解

1 java 一般执行顺序：

1 静态块（静态变量）

2 成员变量

3构造方法

4 静态方法

1 静态代码块（只加载一次）

2 构造方法（创建一个实例加载一次）

3 静态方法需要调用才会执行，

总结：静态代码块不等于静态方法。

静态代码块： static { }

匿名代码块：{}

构造函数： public test() {}

new test();

完成的步骤

1 准备加载类

2 静态变量和静态代码块的加载顺序由编写先后决定

3 new一个类，但在new之前要处理匿名代码块和成员变量

4 按照顺序加载匿名代码块和变量，代码块中有打印

5最后加载构造函数，完成对象的建立

当静态代码块和静态方法同时存在的时候，先执行静态代码块，静态方法调用时候才执行

比如

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

Static{}

先执行 Static{}，main被调用时候执行

如果类还没有被加载：
1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。
2、执行子类的静态代码块和静态变量初始化。
3、执行父类的实例变量初始化
4、执行父类的构造函数
5、执行子类的实例变量初始化
6、执行子类的构造函数

如果类已经被加载：
则静态代码块和静态变量就不用重复执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法。

第一个实例加载类的代码图片
public class test {                         //1.第一步，准备加载类

    public static void main(String[] args) {
        new test();                         //4.第四步，new一个类，但在new之前要处理匿名代码块        
    }

    static int num = 4;                    //2.第二步，静态变量和静态代码块的加载顺序由编写先后决定 

    {
        num += 3;
        System.out.println("b");           //5.第五步，按照顺序加载匿名代码块，代码块中有打印
    }

    int a = 5;                             //6.第六步，按照顺序加载变量

    { // 成员变量第三个
        System.out.println("c");           //7.第七步，按照顺序打印c
    }

    test() { // 类的构造函数，第四个加载
        System.out.println("d");           //8.第八步，最后加载构造函数，完成对象的建立
    }

    static {                              // 3.第三步，静态块，然后执行静态代码块，因为有输出，故打印a
        System.out.println("a");
    }

    static void run()                    // 静态方法，调用的时候才加载// 注意看，e没有加载
    {
        System.out.println("e");
    }
}

public class Print {
     public Print(String s){
         System.out.print(s + " ");
     }
 }
 
 public class Parent{
     public static Print obj1 = new Print("1");
     public Print obj2 = new Print("2");
     public static Print obj3 = new Print("3");
     static{
         new Print("4");
     }
     public static Print obj4 = new Print("5");
     public Print obj5 = new Print("6");
     public Parent(){
         new Print("7");
     }

 }
 public class Child extends Parent{
     static{
         new Print("a");
     }
     public static Print obj1 = new Print("b");
     public Print obj2 = new Print("c");
     public Child (){
         new Print("d");
     }
     public static Print obj3 = new Print("e");
     public Print obj4 = new Print("f");
     public static void main(String [] args){
         Parent obj1 = new Child ();
         Parent obj2 = new Child ();
     }
 }

猜测结果：

先加载类

加载静态变量和静态代码块：

先加载父类：1 3 4 5

再加载子类 a b e

New 类，处理匿名代码块，没有不处理

再加载成员变量和构造函数：

先加载父类成员变量： 2 6

先加载父类构造函数： 7

先加载子类成员变量： c f

先加载子类构造函数： d