类的初始话顺序-CSDN博客

本文链接：https://blog.csdn.net/peijunlin/article/details/3585428

类的初始化顺序为：

（静态变量、静态初始化块）—— 》（变量、初始化块）—— 》构造函数

测试代码：

public class InitialOrderTest {
// 静态变量
public static String staticField = "静态变量";

// 变量
public String field = "变量";

        // 静态初始化块
        static {
                System.out.println(staticField);
                System.out.println("静态初始化块");
         }

        // 初始化块
        {
                System.out.println(field);
                System.out.println("初始化块");
        }

        // 构造器
        public InitialOrderTest() {
                System.out.println("构造器");
        }

        public static void main(String[] args) {
                new InitialOrderTest();
        }
}
运行以上代码，我们会得到如下的输出结果：
1. 静态变量
2. 静态初始化块
3. 变量
4. 初始化块
5. 构造器

B类——extends——A类

创建子类B对象的顺序：

第一步：分配空间（A ,B的空间一次性分配）

第二步：执行（A ,B ）的静态代码块、静态变量 //二者根据调用出现的先后顺序执行

第三步：初始化A的实例变量，A的代码块 //二者根据调用出现的先后顺序执行

第四步：调用A的构造函数

第五步：初始化B的实例变量和代码块

第六步：调用B的构造函数

class Parent {

// 静态变量
public static String p_StaticField = "父类--静态变量";

// 变量
public String p_Field = "父类--变量";

        // 静态初始化块
        static {
                System.out.println(p_StaticField);
                System.out.println("父类--静态初始化块");
        }

        // 初始化块
        {
                System.out.println(p_Field);
                System.out.println("父类--初始化块");
        }

        // 构造器
        public Parent() {
                System.out.println("父类--构造器");
        }
}

public class SubClass extends Parent {

// 静态变量
public static String s_StaticField = "子类--静态变量";

// 变量
public String s_Field = "子类--变量";

        // 静态初始化块
        static {
                System.out.println(s_StaticField);
                System.out.println("子类--静态初始化块");
        }

        // 初始化块
        {
                System.out.println(s_Field);
                System.out.println("子类--初始化块");
        }

        // 构造器
        public SubClass() {
                System.out.println("子类--构造器");
        }

        // 程序入口
        public static void main(String[] args) {
                new SubClass();
        }
}

运行一下上面的代码：
1. 父类--静态变量
2. 父类--静态初始化块
3. 子类--静态变量
4. 子类--静态初始化块
5. 父类--变量
6. 父类--初始化块
7. 父类--构造器
8. 子类--变量
9. 子类--初始化块
10.子类--构造器

注意并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。
那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。

测试：

public class TestOrder {
        // 静态变量
       public static TestA a = new TestA();
       // 静态初始化块
       static {
              System.out.println("静态初始化块");
       }
       // 静态变量
       public static TestB b = new TestB();
       public static void main(String[] args) {
              new TestOrder();
       }
}
class TestA {
       public TestA() {
              System.out.println("Test--A");
       }
}
class TestB {
       public TestB() {
              System.out.println("Test--B");
       }
}