代码块执行顺序：静态、实例、构造器（超详细底层版）
在Java中，代码块（静态代码块、实例代码块）与构造器的执行顺序，是入门级基础知识点，却是面试高频考点、实际开发高频Bug点。很多开发者只记“静态先于实例，实例先于构造器”的表面口诀，却不懂底层执行逻辑，遇到“多静态块、多实例块、继承+变量初始化混合、子类构造器隐式调用父类”等复杂场景时，就会彻底混乱，甚至写出逻辑错误的代码。
一、先搞懂“类加载”与“对象创建”的区别
要彻底理解代码块执行顺序，首先要明确两个核心概念：类加载和对象创建——这是静态代码块与实例代码块、构造器执行顺序不同的根本原因，也是很多人混淆的根源。
1.1 类加载（Class Loading）
• 触发时机：当程序第一次使用某个类（如创建对象、调用静态方法、访问静态变量）时，JVM会将该类的.class字节码文件加载到内存中，这个过程就是类加载。
• 核心目的：初始化类的静态资源（静态变量、静态代码块），为类的使用做准备。
• 执行次数：全局只执行一次，无论后续创建多少个该类的对象，都不会再次触发类加载。
1.2 对象创建（Object Instantiation）
• 触发时机：当执行
new 类名()时，会在类加载完成的基础上，创建类的实例对象。• 核心目的：初始化对象的实例资源（实例变量、实例代码块），最终通过构造器完成对象的完整初始化。
• 执行次数：每次new对象都会执行一次，创建多少个对象，就会执行多少次对象初始化流程。
核心关联
类加载必须在对象创建之前完成——没有加载类，就无法创建该类的对象；类加载完成后，才能多次创建对象，且每次创建对象都不会重复执行类加载流程。
这就决定了：属于类的静态资源（静态代码块、静态变量），必然优先于属于对象的实例资源（实例代码块、实例变量、构造器）执行。
二、三大核心代码块：定义、作用与底层特性
Java中与对象初始化相关的代码块，主要分为三类：静态代码块、实例代码块、构造方法，三者的定义、作用、底层特性完全不同，必须严格区分。
2.1 静态代码块（static block）
定义与语法
用static {}修饰，直接写在类内部，不属于任何方法，是“类级别的代码块”。
public class Person { // 静态代码块 static { System.out.println("静态代码块执行"); // 可执行逻辑：初始化静态变量、加载配置文件、注册驱动等 } }核心特性
• 归属：属于类，而非对象，与对象无关。
• 执行时机：类加载时执行，且只执行一次（无论new多少次对象，都不会重复执行）。
• 执行顺序：在类的所有静态资源初始化完成后，对象创建之前执行。
• 作用：初始化静态变量、加载全局配置（如数据库驱动、配置文件）、执行类级别的初始化逻辑，适合“只需要执行一次”的操作。
补充：多个静态代码块的执行顺序
一个类中可以有多个静态代码块，执行顺序严格按照代码书写的先后顺序，从上到下依次执行。
public class Person { // 静态代码块1 static { System.out.println("静态代码块1"); } // 静态代码块2 static { System.out.println("静态代码块2"); } public static void main(String[] args) { new Person(); new Person(); // 不会重复执行静态代码块 } }运行结果：
静态代码块1 静态代码块22.2 实例代码块（构造代码块 / 普通代码块）
定义与语法
直接用{}修饰，写在类内部，不属于任何方法，是“对象级别的代码块”，也叫构造代码块（因为它与构造器密切相关）。
public class Person { // 实例代码块 { System.out.println("实例代码块执行"); // 可执行逻辑：初始化实例变量、对象创建前的预处理等 } }核心特性
• 归属：属于对象，与类无关。
• 执行时机：每次创建对象时执行，且在构造器执行之前执行（是对象初始化的第一步）。
• 执行顺序：在实例变量初始化完成后，构造器执行之前执行。
• 作用：初始化实例变量、提取多个构造器的公共逻辑（避免代码冗余），适合“每次创建对象都需要执行”的操作。
补充：多个实例代码块的执行顺序
一个类中可以有多个实例代码块，执行顺序同样严格按照代码书写的先后顺序，从上到下依次执行，且都在构造器之前执行。
public class Person { // 实例代码块1 { System.out.println("实例代码块1"); } // 实例代码块2 { System.out.println("实例代码块2"); } // 构造器 public Person() { System.out.println("构造器执行"); } public static void main(String[] args) { new Person(); System.out.println("------第二次创建对象------"); new Person(); } }运行结果：
实例代码块1 实例代码块2 构造器执行 ------第二次创建对象------ 实例代码块1 实例代码块2 构造器执行2.3 构造方法（Constructor）
定义与语法
与类名完全相同，无返回值（注意：不是void），用于对象的最终初始化，是对象创建的最后一步。
public class Person { // 无参构造器 public Person() { System.out.println("无参构造器执行"); } // 有参构造器 public Person(String name) { System.out.println("有参构造器执行，name：" + name); } }核心特性
• 归属：属于对象，是对象初始化的最终步骤。
• 执行时机：每次创建对象时执行，在实例代码块执行完成后执行。
• 执行顺序：在实例变量、实例代码块之后，是对象初始化的最后一步。
• 作用：初始化对象的核心属性、完成对象的最终装配，支持通过参数传递初始化不同状态的对象。
构造器的隐式调用
如果一个类没有显式定义构造器，JVM会自动生成一个无参构造器（默认构造器），默认构造器无任何逻辑，仅用于对象初始化。
如果显式定义了构造器（无论有参还是无参），JVM不会再生成默认无参构造器，此时若想创建无参对象，必须手动定义无参构造器（否则编译报错）。
三、无继承场景执行顺序详解
无继承时，类的结构相对简单，执行顺序主要围绕“类加载”和“对象创建”两个阶段，结合静态资源、实例资源的初始化逻辑，形成固定顺序。
3.1 无继承的完整执行顺序
结合“静态变量、静态代码块、实例变量、实例代码块、构造器”的初始化顺序，无继承场景的完整执行流程如下（按顺序执行）：
1.类加载阶段（只执行一次）：
• 执行静态变量的显式赋值（按代码书写顺序）；
• 执行静态代码块（按代码书写顺序）；
2.对象创建阶段（每次new都执行）：
• 执行实例变量的显式赋值（按代码书写顺序）；
• 执行实例代码块（按代码书写顺序）；
• 执行构造方法（无参/有参，根据new的方式选择）；
核心规则
同级别资源（静态变量与静态代码块、实例变量与实例代码块），执行顺序严格按照代码书写的先后顺序——谁写在前面，谁先执行。
完整代码示例（无继承+混合变量）
public class Person { // 静态变量1（显式赋值） public static String staticVar1 = "静态变量1赋值"; // 静态代码块1 static { System.out.println(staticVar1); System.out.println("静态代码块1执行"); } // 静态变量2（显式赋值） public static String staticVar2 = "静态变量2赋值"; // 静态代码块2 static { System.out.println(staticVar2); System.out.println("静态代码块2执行"); } // 实例变量1（显式赋值） public String instanceVar1 = "实例变量1赋值"; // 实例代码块1 { System.out.println(instanceVar1); System.out.println("实例代码块1执行"); } // 实例变量2（显式赋值） public String instanceVar2 = "实例变量2赋值"; // 实例代码块2 { System.out.println(instanceVar2); System.out.println("实例代码块2执行"); } // 无参构造器 public Person() { System.out.println("无参构造器执行"); } public static void main(String[] args) { System.out.println("------第一次创建对象------"); new Person(); System.out.println("------第二次创建对象------"); new Person(); } }运行结果与分析
静态变量1赋值 静态代码块1执行 静态变量2赋值 静态代码块2执行 ------第一次创建对象------ 实例变量1赋值 实例代码块1执行 实例变量2赋值 实例代码块2执行 无参构造器执行 ------第二次创建对象------ 实例变量1赋值 实例代码块1执行 实例变量2赋值 实例代码块2执行 无参构造器执行分析：
• 类加载阶段：静态变量1赋值 → 静态代码块1 → 静态变量2赋值 → 静态代码块2（按书写顺序），只执行一次；
• 对象创建阶段：每次new对象，都会按“实例变量1 → 实例代码块1 → 实例变量2 → 实例代码块2 → 构造器”的顺序执行，执行两次；
• 静态资源全程只执行一次，实例资源每次new都执行，完全符合“类加载一次，对象创建多次”的底层逻辑。
四、有继承场景执行顺序详解
当出现
extends继承关系时，执行顺序会变得复杂，核心原则是「先父后子」——因为子类的对象创建，必须依赖父类的对象初始化完成（子类继承父类的所有属性和方法，父类未初始化，子类无法使用）。结合类加载和对象创建的底层逻辑，继承场景的执行顺序，本质是“父类类加载→子类类加载→父类对象初始化→子类对象初始化”。
4.1 有继承的完整执行顺序
假设存在父类 Father 和子类 Son（Son extends Father），完整执行顺序如下（按顺序执行，无跳跃）：
1.父类类加载阶段（只执行一次）：
• 父类静态变量显式赋值（按书写顺序）；
• 父类静态代码块（按书写顺序）；
2.子类类加载阶段（只执行一次）：
• 子类静态变量显式赋值（按书写顺序）；
• 子类静态代码块（按书写顺序）；
3.父类对象初始化阶段（每次new子类对象都执行）：
• 父类实例变量显式赋值（按书写顺序）；
• 父类实例代码块（按书写顺序）；
• 父类构造方法（子类构造器会隐式调用父类无参构造器，除非显式调用父类有参构造器）；
4.子类对象初始化阶段（每次new子类对象都执行）：
• 子类实例变量显式赋值（按书写顺序）；
• 子类实例代码块（按书写顺序）；
• 子类构造方法（执行最终的初始化逻辑）；
子类构造器对父类构造器的隐式调用
在子类构造器的第一行，JVM会自动隐式调用父类的无参构造器（即
super()），如果父类没有无参构造器（显式定义了有参构造器，未定义无参），则必须在子类构造器的第一行显式调用父类的有参构造器（super(参数)），否则编译报错。这也是“父类构造器先于子类构造器执行”的核心原因——子类构造器的执行，必须依赖父类构造器先完成父类对象的初始化。
完整代码示例（有继承+混合变量+多代码块）
// 父类 Father class Father { // 父类静态变量1 public static String fatherStaticVar1 = "父类静态变量1赋值"; // 父类静态代码块1 static { System.out.println(fatherStaticVar1); System.out.println("1. 父类静态代码块1执行"); } // 父类静态变量2 public static String fatherStaticVar2 = "父类静态变量2赋值"; // 父类静态代码块2 static { System.out.println(fatherStaticVar2); System.out.println("2. 父类静态代码块2执行"); } // 父类实例变量1 public String fatherInstanceVar1 = "父类实例变量1赋值"; // 父类实例代码块1 { System.out.println(fatherInstanceVar1); System.out.println("3. 父类实例代码块1执行"); } // 父类实例变量2 public String fatherInstanceVar2 = "父类实例变量2赋值"; // 父类实例代码块2 { System.out.println(fatherInstanceVar2); System.out.println("4. 父类实例代码块2执行"); } // 父类无参构造器 public Father() { System.out.println("5. 父类无参构造器执行"); } } // 子类 Son（继承Father） public class Son extends Father { // 子类静态变量1 public static String sonStaticVar1 = "子类静态变量1赋值"; // 子类静态代码块1 static { System.out.println(sonStaticVar1); System.out.println("6. 子类静态代码块1执行"); } // 子类静态变量2 public static String sonStaticVar2 = "子类静态变量2赋值"; // 子类静态代码块2 static { System.out.println(sonStaticVar2); System.out.println("7. 子类静态代码块2执行"); } // 子类实例变量1 public String sonInstanceVar1 = "子类实例变量1赋值"; // 子类实例代码块1 { System.out.println(sonInstanceVar1); System.out.println("8. 子类实例代码块1执行"); } // 子类实例变量2 public String sonInstanceVar2 = "子类实例变量2赋值"; // 子类实例代码块2 { System.out.println(sonInstanceVar2); System.out.println("9. 子类实例代码块2执行"); } // 子类无参构造器（隐式调用父类无参构造器 super()） public Son() { // super(); // JVM自动隐式添加，无需手动写 System.out.println("10. 子类无参构造器执行"); } public static void main(String[] args) { System.out.println("------第一次创建子类对象------"); new Son(); System.out.println("------第二次创建子类对象------"); new Son(); } }运行结果与分析
父类静态变量1赋值 1. 父类静态代码块1执行 父类静态变量2赋值 2. 父类静态代码块2执行 子类静态变量1赋值 6. 子类静态代码块1执行 子类静态变量2赋值 7. 子类静态代码块2执行 ------第一次创建子类对象------ 父类实例变量1赋值 3. 父类实例代码块1执行 父类实例变量2赋值 4. 父类实例代码块2执行 5. 父类无参构造器执行 子类实例变量1赋值 8. 子类实例代码块1执行 子类实例变量2赋值 9. 子类实例代码块2执行 10. 子类无参构造器执行 ------第二次创建子类对象------ 父类实例变量1赋值 3. 父类实例代码块1执行 父类实例变量2赋值 4. 父类实例代码块2执行 5. 父类无参构造器执行 子类实例变量1赋值 8. 子类实例代码块1执行 子类实例变量2赋值 9. 子类实例代码块2执行 10. 子类无参构造器执行分析：
• 类加载阶段：父类静态资源（变量+代码块）先执行，再执行子类静态资源，只执行一次；
• 对象初始化阶段：每次new子类对象，先执行父类的实例资源（变量+代码块+构造器），再执行子类的实例资源（变量+代码块+构造器），执行两次；
• 子类构造器执行前，会隐式调用父类无参构造器，确保父类对象先初始化完成，符合“先父后子”的原则。
六、面试真题
结合前面的知识点，整理3道面试高频真题，帮你快速巩固，应对面试。
真题1：写出以下代码的运行结果
public class A { static { System.out.println("A静态代码块"); } { System.out.println("A实例代码块"); } public A() { System.out.println("A构造器"); } public static void main(String[] args) { new A(); new A(); } }答案：
A静态代码块 A实例代码块 A构造器 A实例代码块 A构造器解析：静态代码块只执行一次，实例代码块和构造器每次new都执行，顺序为“静态→实例→构造器”。
真题2：写出以下继承代码的运行结果
class Parent { static { System.out.println("Parent静态"); } public Parent() { System.out.println("Parent构造器"); } { System.out.println("Parent实例"); } } class Child extends Parent { static { System.out.println("Child静态"); } public Child() { System.out.println("Child构造器"); } { System.out.println("Child实例"); } } public class Test { public static void main(String[] args) { new Child(); } }答案：
Parent静态 Child静态 Parent实例 Parent构造器 Child实例 Child构造器解析：遵循“先静态（父→子），后实例（父→子）”，子类构造器隐式调用父类无参构造器，实例代码块在构造器之前执行。
真题3：写出以下混合代码的运行结果
class X { public static int x = 10; static { x += 5; System.out.println("X静态代码块：x=" + x); } public X() { x += 10; System.out.println("X构造器：x=" + x); } } class Y extends X { public static int y = 20; static { y += x; System.out.println("Y静态代码块：y=" + y); } public Y() { y += x; System.out.println("Y构造器：y=" + y); } } public class Test { public static void main(String[] args) { new Y(); new Y(); } }答案：
X静态代码块：x=15 Y静态代码块：y=35 X构造器：x=25 Y构造器：y=60 X构造器：x=35 Y构造器：y=95解析：
• 类加载：X静态变量x=10 → X静态代码块x=15 → Y静态变量y=20 → Y静态代码块y=20+15=35（只执行一次）；
• 第一次new Y：X实例初始化（构造器x=15+10=25）→ Y实例初始化（构造器y=35+25=60）；
• 第二次new Y：X构造器x=25+10=35 → Y构造器y=60+35=95（静态资源不重复执行）。
七、全文总结
代码块执行顺序的核心，是“类加载”和“对象创建”的底层逻辑，记住以下3点，无论遇到什么复杂场景，都能快速判断：
1.核心原则：先静态（类级），后实例（对象级）；先父类，后子类；同级别，按书写顺序；静态只执行一次，实例每次new都执行。
2.无继承完整顺序：静态变量→静态代码块→实例变量→实例代码块→构造器。
3.有继承完整顺序：父静态变量→父静态代码块→子静态变量→子静态代码块→父实例变量→父实例代码块→父构造器→子实例变量→子实例代码块→子构造器。
面试时，无论题目多复杂，只要按照“类加载→对象创建”的流程，结合“先父后子、同级别按顺序”的原则，一步一步推导，就能得出正确结果；开发中，避免踩“静态代码块重复执行”“父类构造器缺失”“变量未赋值就使用”的坑，就能写出逻辑正确的代码。
