42. 构造代码块与静态代码块

一、构造代码块

构造代码块与静态代码块的定义与基本语法

构造代码块

构造代码块（Instance Initialization Block）是定义在类中、方法外的代码块，没有关键字修饰，仅用 {} 包裹。它在每次创建对象时执行，优先于构造方法。

语法示例：

public class Demo {
    // 构造代码块
    {
        System.out.println("构造代码块执行");
    }
}

静态代码块

静态代码块（Static Initialization Block）是用 static 修饰的代码块，同样定义在类中、方法外。它在类加载时仅执行一次，且优先于构造代码块和构造方法。

语法示例：

public class Demo {
    // 静态代码块
    static {
        System.out.println("静态代码块执行");
    }
}

关键区别

特性	构造代码块	静态代码块
关键字	无	static
执行时机	每次创建对象时	类加载时（仅一次）
执行顺序	在构造方法前，静态块后	类加载时最先执行
常见用途	对象初始化通用逻辑	加载静态资源（如配置文件）

完整示例：

public class BlockExample {
    // 静态代码块
    static {
        System.out.println("静态代码块：类加载时执行");
    }

    // 构造代码块
    {
        System.out.println("构造代码块：每次创建对象时执行");
    }

    public BlockExample() {
        System.out.println("构造方法执行");
    }

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

输出结果：

静态代码块：类加载时执行
构造代码块：每次创建对象时执行
构造方法执行
构造代码块：每次创建对象时执行
构造方法执行

---

执行时机与执行顺序

在Java中，构造代码块和静态代码块的执行时机与顺序是理解它们的关键。下面将详细讲解它们的执行时机以及在不同情况下的执行顺序。

构造代码块的执行时机与顺序

1. 执行时机：

   • 构造代码块在每次创建对象时执行，即在调用构造方法之前执行。
   • 无论调用的是哪个构造方法（无参构造方法或有参构造方法），构造代码块都会执行。

2. 执行顺序：

   • 构造代码块的执行顺序优先于构造方法。
   • 如果类中有多个构造代码块，它们会按照在代码中出现的顺序依次执行。

静态代码块的执行时机与顺序

1. 执行时机：

   • 静态代码块在类加载时执行，且仅执行一次。
   • 类加载通常发生在以下情况：
     • 首次创建类的对象时。
     • 首次访问类的静态成员（静态变量或静态方法）时。
     • 通过Class.forName()显式加载类时。

2. 执行顺序：

   • 静态代码块的执行顺序优先于构造代码块和构造方法。
   • 如果类中有多个静态代码块，它们会按照在代码中出现的顺序依次执行。

综合执行顺序示例

以下代码展示了构造代码块、静态代码块和构造方法的执行顺序：

public class ExecutionOrderExample {
    // 静态代码块 1
    static {
        System.out.println("静态代码块 1 执行");
    }

    // 构造代码块 1
    {
        System.out.println("构造代码块 1 执行");
    }

    public ExecutionOrderExample() {
        System.out.println("无参构造方法执行");
    }

    // 静态代码块 2
    static {
        System.out.println("静态代码块 2 执行");
    }

    // 构造代码块 2
    {
        System.out.println("构造代码块 2 执行");
    }

    public static void main(String[] args) {
        System.out.println("--- 第一次创建对象 ---");
        new ExecutionOrderExample();

        System.out.println("--- 第二次创建对象 ---");
        new ExecutionOrderExample();
    }
}

输出结果：

静态代码块 1 执行
静态代码块 2 执行
--- 第一次创建对象 ---
构造代码块 1 执行
构造代码块 2 执行
无参构造方法执行
--- 第二次创建对象 ---
构造代码块 1 执行
构造代码块 2 执行
无参构造方法执行

关键点总结

1. 静态代码块：

   • 仅在类加载时执行一次。
   • 执行顺序优先于构造代码块和构造方法。
   • 多个静态代码块按代码顺序执行。

2. 构造代码块：

   • 每次创建对象时都会执行。
   • 执行顺序优先于构造方法，但晚于静态代码块。
   • 多个构造代码块按代码顺序执行。

3. 父子类中的执行顺序：

   • 如果存在继承关系，静态代码块的执行顺序是从父类到子类。
   • 构造代码块和构造方法的执行顺序也是从父类到子类。

注意事项

1. 静态代码块通常用于初始化静态变量或执行一些只需执行一次的全局操作。
2. 构造代码块适合用于多个构造方法中重复的初始化代码。
3. 避免在静态代码块中编写复杂的逻辑，以免影响类加载性能。

---

构造代码块与构造方法的关系

概念定义

1. 构造代码块：定义在类中、方法外，用 {} 包围的代码块。每次创建对象时都会执行，且在构造方法之前执行。
2. 构造方法：用于初始化对象的特殊方法，名称与类名相同，在 new 时调用。

执行顺序

1. 静态代码块（如果存在，仅类加载时执行一次）
2. 构造代码块（每次实例化时执行）
3. 构造方法（最后执行）

核心关系

1. 执行时机
   构造代码块是构造方法的"前置处理器"，二者共同完成对象初始化：

   class Person {
       { System.out.println("构造代码块"); } // 先执行
       Person() { System.out.println("构造方法"); } // 后执行
   }
   

2. 代码复用
   当多个构造方法有相同初始化逻辑时，可用构造代码块避免重复：

   class Database {
       private Connection conn;
       
       { // 所有构造方法都会执行的公共初始化
           conn = DriverManager.getConnection(...);
       }
       
       Database() { /* 其他逻辑 */ }
       Database(String config) { /* 其他逻辑 */ }
   }
   

3. **初始化优先级
   成员变量赋值 > 构造代码块 > 构造方法
   示例：

   class Test {
       int x = 10;          // 第一步
       { x = 20; }          // 第二步
       Test() { x = 30; }   // 第三步
   }
   // new Test() 最终 x=30
   

注意事项

1. 与静态代码块区别
   静态代码块用 static{} 定义，只在类加载时执行一次，而构造代码块每次 new 都会执行。

2. 继承场景下的执行顺序
   父类构造代码块 → 父类构造方法 → 子类构造代码块 → 子类构造方法

3. 异常处理
   构造代码块中若抛出异常，会阻止对象创建：

   class ErrorExample {
       { if(true) throw new RuntimeException(); }
       ErrorExample() { System.out.println("不会执行"); }
   }
   

典型使用场景

1. 资源初始化（如IO流、数据库连接）
2. 对象状态校验（如参数合法性检查）
3. 日志记录（记录对象创建信息）

通过这种设计，Java实现了对象初始化逻辑的模块化和复用。

---

构造代码块在对象初始化中的作用

概念定义

构造代码块（Instance Initializer Block）是Java中一种特殊的代码块，它没有名称，没有修饰符，也没有参数，仅由一对大括号 {} 组成。构造代码块会在每次创建对象时执行，且执行顺序早于构造方法。

核心作用

1. 初始化实例成员变量：可以在构造代码块中对对象的实例变量进行初始化。
2. 代码复用：当多个构造方法中有相同的初始化代码时，可以提取到构造代码块中，避免重复。
3. 执行预处理逻辑：可以在对象构造前执行一些必要的预处理操作。

执行顺序

在对象初始化过程中，构造代码块的执行顺序如下：

1. 静态代码块（如果类未被加载过）
2. 实例变量默认初始化
3. 实例变量显式初始化（如 int x = 10;）
4. 构造代码块
5. 构造方法

示例代码

public class Person {
    private String name;
    private int age;
    
    // 构造代码块
    {
        System.out.println("执行构造代码块");
        name = "默认姓名";
        age = 18;
    }
    
    public Person() {
        System.out.println("执行无参构造方法");
    }
    
    public Person(String name) {
        this.name = name;
        System.out.println("执行有参构造方法");
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("张三");
    }
}

输出结果：

执行构造代码块
执行无参构造方法
执行构造代码块
执行有参构造方法

使用场景

1. 当多个构造方法需要共享相同的初始化代码时
2. 当需要在构造方法执行前进行一些复杂初始化时
3. 匿名内部类中初始化实例变量（因为匿名内部类不能有构造方法）

注意事项

1. 构造代码块会在每个构造方法执行前都被执行
2. 一个类中可以有多个构造代码块，按它们在代码中出现的顺序依次执行
3. 构造代码块不能接收任何参数
4. 构造代码块中可以使用this关键字引用当前对象
5. 构造代码块中不能直接使用return语句

与构造方法的区别

1. 构造代码块没有名称，而构造方法与类名相同
2. 构造代码块不能接收参数，构造方法可以
3. 构造代码块在每个构造方法前都会执行，而构造方法只会执行一个

高级用法

构造代码块可以用于初始化匿名内部类：

Runnable r = new Runnable() {
    private int count;
    
    // 匿名内部类中的构造代码块
    {
        count = 10;
    }
    
    @Override
    public void run() {
        System.out.println(count);
    }
};

性能考虑

虽然构造代码块提供了便利，但过度使用可能会影响性能，因为其中的代码会在每次对象创建时都执行。对于不需要每次对象创建都执行的初始化逻辑，应考虑使用静态代码块。

---

多个构造代码块的执行顺序

概念定义

构造代码块（Instance Initialization Block）是 Java 中一种特殊的代码块，定义在类中但不在任何方法或构造函数内。它的主要作用是在每次创建对象时执行一些初始化逻辑。如果一个类中有多个构造代码块，它们会按照在类中定义的顺序依次执行。

执行顺序规则

1. 构造代码块在构造函数之前执行：无论调用哪个构造函数，构造代码块都会先执行。
2. 多个构造代码块按定义顺序执行：代码块在类中的书写顺序决定了它们的执行顺序。

示例代码

public class Example {
    // 第一个构造代码块
    {
        System.out.println("第一个构造代码块执行");
    }

    public Example() {
        System.out.println("无参构造函数执行");
    }

    // 第二个构造代码块
    {
        System.out.println("第二个构造代码块执行");
    }

    public Example(String message) {
        System.out.println("有参构造函数执行: " + message);
    }

    public static void main(String[] args) {
        new Example();
        System.out.println("------");
        new Example("Hello");
    }
}

输出结果

第一个构造代码块执行
第二个构造代码块执行
无参构造函数执行
------
第一个构造代码块执行
第二个构造代码块执行
有参构造函数执行: Hello

关键点说明

1. 无论调用哪个构造函数，所有构造代码块都会执行。
2. 顺序是固定的：先定义的构造代码块先执行，与构造函数无关。
3. 与字段初始化器的关系：如果类中还有字段初始化（如 int x = 10;），构造代码块和字段初始化会按代码中的顺序混合执行。

实际应用场景

• 当多个构造函数需要共享一段初始化代码时，可以用构造代码块避免重复。
• 适合初始化复杂的对象状态，尤其是需要多步操作的情况。

注意事项

• 避免在构造代码块中编写过于复杂的逻辑，否则会降低代码可读性。
• 如果初始化逻辑仅针对部分构造函数，直接写在构造函数内更合适。

---

继承中的构造代码块执行

构造代码块的定义

构造代码块是定义在类中、方法外，用 {} 包围的代码块。它在每次创建对象时都会执行，且执行顺序优先于构造函数。

继承中的执行顺序

在继承体系中，构造代码块的执行遵循以下顺序：

1. 父类的静态代码块（如果未加载）
2. 子类的静态代码块（如果未加载）
3. 父类的构造代码块
4. 父类的构造函数
5. 子类的构造代码块
6. 子类的构造函数

示例代码

class Parent {
    // 父类构造代码块
    {
        System.out.println("Parent的构造代码块");
    }
    
    public Parent() {
        System.out.println("Parent的无参构造");
    }
}

class Child extends Parent {
    // 子类构造代码块
    {
        System.out.println("Child的构造代码块");
    }
    
    public Child() {
        System.out.println("Child的无参构造");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

输出结果

Parent的构造代码块
Parent的无参构造
Child的构造代码块
Child的无参构造

关键特点

1. 多次执行：每次new对象时都会执行对应的构造代码块
2. 隐式调用：编译器会自动将构造代码块合并到每个构造函数的最开始处
3. 与静态代码块区别：静态代码块只在类加载时执行一次

使用场景

1. 多个构造函数共用的初始化代码
2. 需要在构造函数之前执行的通用逻辑
3. 匿名内部类的初始化

注意事项

1. 构造代码块不能接收参数
2. 执行顺序可能导致字段初始化的覆盖
3. 避免在构造代码块中编写复杂逻辑
4. 在继承体系中要特别注意父类和子类的执行顺序

进阶示例（含字段初始化）

class A {
    int x = 10;
    {
        System.out.println("A的构造代码块: x=" + x);
        x = 20;
    }
    
    public A() {
        System.out.println("A的构造: x=" + x);
    }
}

class B extends A {
    int y = 100;
    {
        System.out.println("B的构造代码块: y=" + y);
        y = 200;
    }
    
    public B() {
        System.out.println("B的构造: y=" + y);
    }
}

public class Main {
    public static void main(String[] args) {
        new B();
    }
}

输出结果

A的构造代码块: x=10
A的构造: x=20
B的构造代码块: y=100
B的构造: y=200

---

使用场景与最佳实践

构造代码块的使用场景

1. 初始化实例变量
   当多个构造方法需要共享相同的初始化逻辑时，可以将这部分代码提取到构造代码块中，避免重复编写。例如：

   public class Person {
       private String name;
       private int age;
       
       // 构造代码块
       {
           name = "Unknown";
           age = 0;
       }
       
       public Person() {}
       public Person(String name) {
           this.name = name;
       }
   }
   

2. 执行构造前的公共逻辑
   比如日志记录、权限检查等需要在对象构造时统一执行的逻辑。

3. 匿名内部类的初始化
   匿名内部类无法定义构造方法，可以通过构造代码块初始化成员：

   Runnable r = new Runnable() {
       private String message;
       
       {
           message = "Hello";
       }
       
       @Override
       public void run() {
           System.out.println(message);
       }
   };
   

静态代码块的使用场景

1. 加载静态资源
   常用于初始化静态变量或加载配置文件、驱动等只需执行一次的操作：

   public class Database {
       private static Connection conn;
       
       static {
           try {
               conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

2. 复杂静态变量初始化
   当静态变量的初始化需要多步逻辑时：

   public class Constants {
       public static final Map<String, String> CONFIG;
       
       static {
           CONFIG = new HashMap<>();
           CONFIG.put("timeout", "30s");
           CONFIG.put("maxRetry", "3");
       }
   }
   

3. 类加载时的验证
   例如检查运行时环境是否符合要求：

   static {
       if (System.getProperty("java.version").startsWith("1.7")) {
           throw new RuntimeException("需要Java 8或更高版本");
       }
   }
   

最佳实践

1. 构造代码块

   • 避免过度使用：仅在多个构造方法有真正共享逻辑时使用
   • 不要放入复杂业务逻辑，保持简洁性
   • 注意执行顺序：父类构造代码块 → 父类构造方法 → 子类构造代码块 → 子类构造方法

2. 静态代码块

   • 处理异常：静态代码块中的异常应转换为RuntimeException
   • 性能考虑：避免在静态代码块中执行耗时操作
   • 线程安全：静态代码块是线程安全的，但需注意后续对静态变量的操作
   • 替代方案：对于简单初始化，优先使用静态变量直接赋值：

     // 优于静态代码块
     private static final List<String> NAMES = Arrays.asList("A", "B");
     

3. 综合示例

   public class ResourceLoader {
       private static final Logger LOGGER;
       private static Properties config;
       
       static {
           LOGGER = LoggerFactory.getLogger(ResourceLoader.class);
           try (InputStream is = ResourceLoader.class.getResourceAsStream("/app.conf")) {
               config = new Properties();
               config.load(is);
           } catch (IOException e) {
               LOGGER.error("加载配置失败", e);
               throw new RuntimeException("初始化失败", e);
           }
       }
       
       {
           LOGGER.info("创建新的ResourceLoader实例");
       }
   }
   

---

常见错误与注意事项

1. 静态代码块的执行顺序误解

• 错误示例：认为静态代码块的执行顺序与类中定义的顺序无关。
• 正确理解：静态代码块按照在类中定义的顺序执行，且仅在类加载时执行一次。
• 注意事项：如果类中有多个静态代码块，它们的执行顺序会影响静态变量的初始化结果。

2. 构造代码块与构造方法的混淆

• 错误示例：误以为构造代码块可以替代构造方法。
• 正确理解：构造代码块用于提取多个构造方法的公共代码，但它不能替代构造方法，因为构造方法可以接收参数并完成特定初始化。
• 注意事项：构造代码块会在每个构造方法执行前自动调用，但无法直接传递参数。

3. 静态代码块中访问非静态成员

• 错误示例：在静态代码块中直接访问非静态变量或方法。

public class Example {
    int x = 10; // 非静态变量
    static {
        System.out.println(x); // 编译错误：无法从静态上下文中引用非静态变量x
    }
}

• 注意事项：静态代码块只能访问静态成员，因为它在类加载时执行，此时对象尚未创建。

4. 构造代码块中处理异常

• 错误示例：在构造代码块中抛出检查异常（checked exception）但没有在构造方法中声明。

public class Example {
    {
        throw new IOException(); // 编译错误：未处理的异常类型IOException
    }
    public Example() throws IOException { // 必须声明
    }
}

• 注意事项：如果构造代码块可能抛出检查异常，所有构造方法都必须声明抛出该异常。

5. 静态代码块的循环依赖

• 错误示例：多个类的静态代码块相互依赖导致死锁或初始化失败。

class A {
    static {
        System.out.println(B.x); // 依赖B的静态初始化
    }
    static int x = 10;
}

class B {
    static {
        System.out.println(A.x); // 依赖A的静态初始化
    }
    static int x = 20;
}

• 注意事项：避免在静态代码块中形成跨类的循环依赖，否则会导致NoClassDefFoundError。

6. 性能问题

• 错误示例：在静态代码块中执行耗时操作（如数据库连接、网络请求）。
• 注意事项：静态代码块在类加载时执行，耗时操作会延迟类的可用性，应考虑懒加载模式。

7. 继承中的执行顺序

• 错误示例：忽略父类和子类中静态代码块/构造代码块的执行顺序。
• 正确顺序：
  1. 父类静态代码块
  2. 子类静态代码块
  3. 父类构造代码块 → 父类构造方法
  4. 子类构造代码块 → 子类构造方法
• 注意事项：在继承体系中要清楚初始化顺序，避免依赖未初始化的资源。

---

二、静态代码块

构造代码块与静态代码块的定义与基本语法

构造代码块

构造代码块（Instance Initialization Block）是定义在类中、方法外的代码块，没有关键字修饰，仅用 {} 包裹。它在每次创建对象时执行，优先于构造方法。

语法示例：

public class Demo {
    // 构造代码块
    {
        System.out.println("构造代码块执行");
    }
}

静态代码块

静态代码块（Static Initialization Block）是用 static 修饰的代码块，同样定义在类中、方法外。它在类加载时仅执行一次，且优先于构造代码块和构造方法。

语法示例：

public class Demo {
    // 静态代码块
    static {
        System.out.println("静态代码块执行");
    }
}

关键区别

特性	构造代码块	静态代码块
关键字	无	static
执行时机	每次创建对象时	类加载时（仅一次）
执行顺序	在构造方法前，静态块后	类加载时最先执行
常见用途	对象初始化通用逻辑	加载静态资源（如配置文件）

完整示例：

public class BlockExample {
    // 静态代码块
    static {
        System.out.println("静态代码块：类加载时执行");
    }

    // 构造代码块
    {
        System.out.println("构造代码块：每次创建对象时执行");
    }

    public BlockExample() {
        System.out.println("构造方法执行");
    }

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

输出结果：

静态代码块：类加载时执行
构造代码块：每次创建对象时执行
构造方法执行
构造代码块：每次创建对象时执行
构造方法执行

---

static 关键字的作用

概念定义

static 是 Java 中的一个关键字，用于修饰类的成员（变量、方法、代码块和嵌套类），使其成为类成员而非实例成员。这意味着：

• 被 static 修饰的成员属于类本身，而不是类的某个具体实例。
• 静态成员在类加载时初始化，且只有一份内存空间，被所有实例共享。

使用场景

1. 静态变量（类变量）

   • 用于表示类的共享数据（如常量、计数器等）。
   • 示例：

     class Counter {
         static int count = 0; // 所有实例共享的计数器
         Counter() {
             count++;
         }
     }
     

2. 静态方法

   • 不依赖于实例状态，可直接通过类名调用。
   • 常用于工具类方法（如 Math.sqrt()）。
   • 示例：

     class MathUtils {
         static double circleArea(double radius) {
             return Math.PI * radius * radius;
         }
     }
     // 调用：MathUtils.circleArea(5.0)
     

3. 静态代码块

   • 在类加载时执行，用于初始化静态资源（如加载配置文件）。
   • 示例：

     class Database {
         static Connection conn;
         static {
             try {
                 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb");
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
     }
     

4. 静态嵌套类

   • 静态内部类不持有外部类的引用，可独立存在。
   • 示例：

     class Outer {
         static class Nested {
             void show() {
                 System.out.println("Static nested class");
             }
         }
     }
     // 调用：new Outer.Nested().show()
     

注意事项

1. 访问限制

   • 静态方法中不能直接访问非静态成员（需通过对象实例）。
   • 非静态方法可以访问静态成员。

2. 内存效率

   • 静态变量占用固定内存（类加载时分配），滥用可能导致内存浪费。

3. 线程安全

   • 静态变量是共享资源，多线程环境下需同步控制（如加锁）。

4. 继承与重写

   • 静态方法不能被重写（隐藏而非多态）。
   • 示例：

     class Parent {
         static void show() { System.out.println("Parent"); }
     }
     class Child extends Parent {
         static void show() { System.out.println("Child"); } // 隐藏父类方法
     }
     // 调用 Parent.show() 输出 "Parent"，Child.show() 输出 "Child"
     

示例代码

public class StaticDemo {
    static int sharedValue = 10; // 静态变量

    static { // 静态代码块
        System.out.println("类已加载，sharedValue=" + sharedValue);
    }

    static void printValue() { // 静态方法
        System.out.println("静态方法访问: " + sharedValue);
    }

    public static void main(String[] args) {
        StaticDemo.printValue(); // 直接通过类名调用
        StaticDemo obj1 = new StaticDemo();
        StaticDemo obj2 = new StaticDemo();
        obj1.sharedValue = 20;    // 修改静态变量（所有实例生效）
        System.out.println("obj2.sharedValue=" + obj2.sharedValue); // 输出20
    }
}

---

执行时机与执行顺序

在Java中，构造代码块和静态代码块的执行时机与顺序是理解它们的关键。下面将详细讲解它们的执行时机以及在不同情况下的执行顺序。

构造代码块的执行时机与顺序

1. 执行时机：

   • 构造代码块在每次创建对象时执行，即在调用构造方法之前执行。
   • 无论调用的是哪个构造方法（无参构造方法或有参构造方法），构造代码块都会执行。

2. 执行顺序：

   • 构造代码块的执行顺序优先于构造方法。
   • 如果类中有多个构造代码块，它们会按照在代码中出现的顺序依次执行。

静态代码块的执行时机与顺序

1. 执行时机：

   • 静态代码块在类加载时执行，且仅执行一次。
   • 类加载通常发生在以下情况：
     • 首次创建类的对象时。
     • 首次访问类的静态成员（静态变量或静态方法）时。
     • 通过Class.forName()显式加载类时。

2. 执行顺序：

   • 静态代码块的执行顺序优先于构造代码块和构造方法。
   • 如果类中有多个静态代码块，它们会按照在代码中出现的顺序依次执行。

综合执行顺序示例

以下代码展示了构造代码块、静态代码块和构造方法的执行顺序：

public class ExecutionOrderExample {
    // 静态代码块 1
    static {
        System.out.println("静态代码块 1 执行");
    }

    // 构造代码块 1
    {
        System.out.println("构造代码块 1 执行");
    }

    public ExecutionOrderExample() {
        System.out.println("无参构造方法执行");
    }

    // 静态代码块 2
    static {
        System.out.println("静态代码块 2 执行");
    }

    // 构造代码块 2
    {
        System.out.println("构造代码块 2 执行");
    }

    public static void main(String[] args) {
        System.out.println("--- 第一次创建对象 ---");
        new ExecutionOrderExample();

        System.out.println("--- 第二次创建对象 ---");
        new ExecutionOrderExample();
    }
}

输出结果：

静态代码块 1 执行
静态代码块 2 执行
--- 第一次创建对象 ---
构造代码块 1 执行
构造代码块 2 执行
无参构造方法执行
--- 第二次创建对象 ---
构造代码块 1 执行
构造代码块 2 执行
无参构造方法执行

关键点总结

1. 静态代码块：

   • 仅在类加载时执行一次。
   • 执行顺序优先于构造代码块和构造方法。
   • 多个静态代码块按代码顺序执行。

2. 构造代码块：

   • 每次创建对象时都会执行。
   • 执行顺序优先于构造方法，但晚于静态代码块。
   • 多个构造代码块按代码顺序执行。

3. 父子类中的执行顺序：

   • 如果存在继承关系，静态代码块的执行顺序是从父类到子类。
   • 构造代码块和构造方法的执行顺序也是从父类到子类。

注意事项

1. 静态代码块通常用于初始化静态变量或执行一些只需执行一次的全局操作。
2. 构造代码块适合用于多个构造方法中重复的初始化代码。
3. 避免在静态代码块中编写复杂的逻辑，以免影响类加载性能。

---

类加载过程中的作用

概念定义

构造代码块和静态代码块在类加载过程中扮演着不同的角色：

1. 静态代码块（static block）：

   • 在类被JVM加载时执行（首次主动使用时）
   • 只执行一次
   • 用于初始化类的静态成员

2. 构造代码块（instance initializer block）：

   • 在每次创建对象实例时执行
   • 在构造函数之前执行
   • 用于初始化实例成员

执行时机对比

代码块类型	执行时机	执行次数	作用域
静态代码块	类加载时	1次	类级别
构造代码块	对象实例化时	每次new都执行	实例级别

执行顺序示例

public class BlockExample {
    static {
        System.out.println("静态代码块执行");
    }
    
    {
        System.out.println("构造代码块执行");
    }
    
    public BlockExample() {
        System.out.println("构造函数执行");
    }
    
    public static void main(String[] args) {
        new BlockExample();
        new BlockExample();
    }
}

输出结果：

静态代码块执行
构造代码块执行
构造函数执行
构造代码块执行
构造函数执行

典型使用场景

1. 静态代码块：

   • 加载静态资源（如配置文件）
   • 初始化静态容器
   • 注册驱动（如JDBC驱动注册）

   public class DBUtil {
       private static Properties config;
       
       static {
           config = new Properties();
           try {
               config.load(ClassLoader.getSystemResourceAsStream("db.properties"));
           } catch (IOException e) {
               throw new RuntimeException("加载配置文件失败");
           }
       }
   }
   

2. 构造代码块：

   • 多个构造函数共用的初始化逻辑
   • 复杂的对象初始化
   • 日志记录

   public class User {
       private String name;
       private Date createTime;
       
       {
           createTime = new Date(); // 所有构造函数都会执行的初始化
       }
       
       public User(String name) {
           this.name = name;
       }
       
       public User() {
           this("匿名用户");
       }
   }
   

注意事项

1. 静态代码块：

   • 不能访问非静态成员
   • 异常必须处理，不能抛出
   • 多个静态块按声明顺序执行

2. 构造代码块：

   • 会在super()调用后执行
   • 可以访问静态和非静态成员
   • 多个构造块按声明顺序执行

高级特性

1. 静态导入：

   import static com.example.Constants.*;
   
   public class Importer {
       static {
           System.out.println(VERSION); // 使用静态导入的常量
       }
   }
   

2. 匿名类的构造块：

   Runnable r = new Runnable() {
       {
           System.out.println("匿名类构造块");
       }
       
       public void run() {
           // ...
       }
   };
   

3. 与继承的关系：

   • 父类静态块 → 子类静态块 → 父类构造块 → 父类构造器 → 子类构造块 → 子类构造器

常见误区

1. 错误认为构造代码块会替代构造函数
2. 在静态代码块中尝试访问实例变量
3. 忽略代码块的执行顺序导致初始化问题
4. 在接口中使用静态代码块（Java 8+允许）

性能考虑

1. 静态代码块的执行会影响类加载性能
2. 复杂的构造代码块会影响对象创建速度
3. 应当避免在代码块中进行耗时操作

---

多个静态代码块的执行顺序

概念定义

静态代码块（Static Block）是使用 static 关键字修饰的代码块，它在类加载时执行，且仅执行一次。如果一个类中包含多个静态代码块，它们会按照在代码中的声明顺序依次执行。

执行顺序规则

1. 按声明顺序执行：多个静态代码块在类中的位置决定了它们的执行顺序。先声明的先执行，后声明的后执行。
2. 在类加载时执行：静态代码块在类首次被加载到 JVM 时执行（如首次创建对象、访问静态成员等）。
3. 仅执行一次：无论创建多少个对象，静态代码块只会执行一次。

示例代码

public class StaticBlockDemo {
    // 第一个静态代码块
    static {
        System.out.println("静态代码块1执行");
    }

    // 第二个静态代码块
    static {
        System.out.println("静态代码块2执行");
    }

    public static void main(String[] args) {
        System.out.println("main方法执行");
    }
}

输出结果

静态代码块1执行
静态代码块2执行
main方法执行

注意事项

1. 静态代码块通常用于初始化静态变量，如果多个静态代码块之间存在依赖关系，需注意声明顺序。
2. 静态代码块不能访问非静态成员，因为它在对象创建之前执行。
3. 如果静态代码块抛出异常，类加载会失败，导致 NoClassDefFoundError。

与构造代码块的区别

• 构造代码块在每次创建对象时执行，而静态代码块仅在类加载时执行一次。
• 构造代码块可以访问非静态成员，静态代码块只能访问静态成员。

---

静态代码块与静态变量的初始化顺序

概念定义

静态代码块（static block）和静态变量（static variable）都是类级别的成员，它们在类加载时进行初始化。静态变量是类中声明为static的成员变量，而静态代码块是用static关键字修饰的代码块。

初始化顺序规则

1. 静态变量声明时的默认初始化：所有静态变量首先被赋予默认值（如int为0，对象引用为null等）。
2. 静态变量的显式初始化和静态代码块的执行：按照在源代码中出现的书写顺序依次执行。

示例代码

public class InitializationOrder {
    // 静态变量1
    static int a = 1;
    
    // 静态代码块1
    static {
        System.out.println("静态代码块1: a = " + a);
        b = 3;  // 可以赋值，但不能读取
        // System.out.println(b); // 编译错误：非法前向引用
    }
    
    // 静态变量2
    static int b = 2;
    
    // 静态代码块2
    static {
        System.out.println("静态代码块2: b = " + b);
    }
    
    public static void main(String[] args) {
        System.out.println("main方法执行");
    }
}

输出结果

静态代码块1: a = 1
静态代码块2: b = 2
main方法执行

关键注意事项

1. 前向引用限制：

   • 在静态代码块中可以给后面声明的静态变量赋值
   • 但不能读取后面声明的静态变量的值（会导致编译错误）

2. 初始化顺序重要性：

   • 当静态变量依赖其他静态变量初始化时，必须确保依赖的变量先初始化
   • 错误的顺序可能导致变量得到错误的初始值

3. 类加载时机：

   • 这些初始化操作只在类第一次被加载时执行一次
   • 类加载的触发条件包括：
     • 创建类的实例
     • 访问类的静态成员
     • 使用Class.forName()加载类

实际应用场景

1. 静态资源配置：如数据库连接池的初始化
2. 常量预计算：复杂静态常量的初始化
3. 单例模式实现：利用静态代码块实现线程安全的单例

错误示例

public class WrongOrder {
    static {
        System.out.println(x);  // 编译错误：非法前向引用
    }
    static int x = 10;
}

最佳实践建议

1. 将相关的静态变量和静态代码块集中放置
2. 保持简单的初始化逻辑，避免复杂的相互依赖
3. 对于复杂的静态初始化，考虑使用静态方法代替静态代码块

---

继承中的静态代码块执行

概念定义

静态代码块（static block）是用 static 关键字修饰的代码块，在类加载时执行，且仅执行一次。在继承关系中，静态代码块的执行顺序遵循类加载的顺序。

执行顺序规则

1. 父类优先原则：在继承体系中，父类的静态代码块会先于子类的静态代码块执行。
2. 类加载触发条件：
   • 首次创建类的实例时（new 操作）。
   • 首次访问类的静态成员（静态变量或静态方法）时。
3. 单次执行：即使多次实例化子类，静态代码块也仅执行一次。

示例代码

class Parent {
    static {
        System.out.println("父类静态代码块执行");
    }
}

class Child extends Parent {
    static {
        System.out.println("子类静态代码块执行");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child(); // 触发类加载
    }
}

输出结果

父类静态代码块执行
子类静态代码块执行

多级继承场景

在多层继承中，静态代码块的执行顺序从最顶层的父类开始，依次向下到最终的子类。

class GrandParent {
    static {
        System.out.println("祖父类静态代码块");
    }
}

class Parent extends GrandParent {
    static {
        System.out.println("父类静态代码块");
    }
}

class Child extends Parent {
    static {
        System.out.println("子类静态代码块");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

输出结果

祖父类静态代码块
父类静态代码块
子类静态代码块

注意事项

1. 静态代码块与构造代码块的区别：
   • 静态代码块在类加载时执行，构造代码块在每次实例化对象时执行。
2. 主动引用 vs 被动引用：
   • 通过子类引用父类的静态字段（如 Child.parentStaticField）不会触发子类的静态代码块执行，仅触发父类的类加载。
3. 接口中的静态代码块：
   • 接口的静态代码块在首次访问接口的静态成员时执行，但接口的继承关系不影响静态代码块的执行顺序（接口无实例化过程）。

常见误区

• 误认为子类实例化会重复执行父类静态代码块：实际上，父类的静态代码块仅在父类首次加载时执行一次。
• 混淆静态代码块与构造方法的顺序：静态代码块的执行远早于构造方法，属于类加载阶段的行为。

实际应用场景

1. 初始化静态资源：如加载数据库驱动（Class.forName("com.mysql.jdbc.Driver")）。
2. 全局配置加载：在类加载时读取配置文件到静态变量中。
3. 复杂静态变量初始化：当静态变量需要多步计算时，可用静态代码块组织逻辑。

---

使用场景与最佳实践

构造代码块的使用场景

1. 初始化实例变量
   当多个构造方法需要共享相同的初始化逻辑时，可以将这部分代码提取到构造代码块中，避免重复编写。例如：

   public class Person {
       private String name;
       private int age;
       
       // 构造代码块
       {
           name = "Unknown";
           age = 0;
       }
       
       public Person() {}
       public Person(String name) {
           this.name = name;
       }
   }
   

2. 执行构造前的公共逻辑
   比如日志记录、权限检查等需要在对象构造时统一执行的逻辑。

3. 匿名内部类的初始化
   匿名内部类无法定义构造方法，可以通过构造代码块初始化成员：

   Runnable r = new Runnable() {
       private String message;
       
       {
           message = "Hello";
       }
       
       @Override
       public void run() {
           System.out.println(message);
       }
   };
   

静态代码块的使用场景

1. 加载静态资源
   常用于初始化静态变量或加载配置文件、驱动等只需执行一次的操作：

   public class Database {
       private static Connection conn;
       
       static {
           try {
               conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   

2. 复杂静态变量初始化
   当静态变量的初始化需要多步逻辑时：

   public class Constants {
       public static final Map<String, String> CONFIG;
       
       static {
           CONFIG = new HashMap<>();
           CONFIG.put("timeout", "30s");
           CONFIG.put("maxRetry", "3");
       }
   }
   

3. 类加载时的验证
   例如检查运行时环境是否符合要求：

   static {
       if (System.getProperty("java.version").startsWith("1.7")) {
           throw new RuntimeException("需要Java 8或更高版本");
       }
   }
   

最佳实践

1. 构造代码块

   • 避免过度使用：仅在多个构造方法有真正共享逻辑时使用
   • 不要放入复杂业务逻辑，保持简洁性
   • 注意执行顺序：父类构造代码块 → 父类构造方法 → 子类构造代码块 → 子类构造方法

2. 静态代码块

   • 处理异常：静态代码块中的异常应转换为RuntimeException
   • 性能考虑：避免在静态代码块中执行耗时操作
   • 线程安全：静态代码块是线程安全的，但需注意后续对静态变量的操作
   • 替代方案：对于简单初始化，优先使用静态变量直接赋值：

     // 优于静态代码块
     private static final List<String> NAMES = Arrays.asList("A", "B");
     

3. 综合示例

   public class ResourceLoader {
       private static final Logger LOGGER;
       private static Properties config;
       
       static {
           LOGGER = LoggerFactory.getLogger(ResourceLoader.class);
           try (InputStream is = ResourceLoader.class.getResourceAsStream("/app.conf")) {
               config = new Properties();
               config.load(is);
           } catch (IOException e) {
               LOGGER.error("加载配置失败", e);
               throw new RuntimeException("初始化失败", e);
           }
       }
       
       {
           LOGGER.info("创建新的ResourceLoader实例");
       }
   }
   

---

三、两者的对比

执行时机的区别

构造代码块的执行时机

1. 定义：构造代码块（非静态代码块）在每次创建类的实例时执行。
2. 触发条件：每次调用 new 关键字实例化对象时触发。
3. 执行顺序：
   • 在成员变量初始化之后执行。
   • 在构造函数之前执行。
4. 特点：
   • 每次实例化都会执行一次。
   • 用于多个构造函数共享的初始化逻辑。

静态代码块的执行时机

1. 定义：静态代码块在类加载到 JVM 时执行，且仅执行一次。
2. 触发条件：
   • 类首次被主动使用时（如创建实例、访问静态成员等）。
   • 类通过 Class.forName() 加载时。
3. 执行顺序：
   • 在类加载的初始化阶段执行。
   • 优先于构造代码块和构造函数。
4. 特点：
   • 仅执行一次，与实例化次数无关。
   • 用于初始化静态资源（如加载配置文件）。

对比示例代码

public class ExecutionTiming {
    // 静态代码块
    static {
        System.out.println("静态代码块执行（类加载时）");
    }

    // 构造代码块
    {
        System.out.println("构造代码块执行（每次实例化时）");
    }

    public ExecutionTiming() {
        System.out.println("构造函数执行");
    }

    public static void main(String[] args) {
        new ExecutionTiming(); // 第一次实例化
        new ExecutionTiming(); // 第二次实例化
    }
}

输出结果

静态代码块执行（类加载时）
构造代码块执行（每次实例化时）
构造函数执行
构造代码块执行（每次实例化时）
构造函数执行

关键区别总结

特性	构造代码块	静态代码块
执行次数	每次实例化时执行	仅类加载时执行一次
执行顺序	在构造函数之前	在类加载的初始化阶段
依赖关系	依赖对象实例	依赖类的加载
典型用途	对象公共初始化	静态资源初始化

---

构造代码块与静态代码块的作用范围区别

构造代码块的作用范围

1. 实例级别：构造代码块作用于类的每个实例对象。
2. 执行时机：每次创建类的实例时都会执行，且在构造函数之前执行。
3. 访问权限：
   • 可以访问实例变量（非静态成员）
   • 可以调用实例方法
   • 不能直接访问静态成员（需要通过类名访问）

示例代码：

public class Example {
    // 实例变量
    private int x;
    
    // 构造代码块
    {
        x = 10;  // 可以访问实例变量
        System.out.println("构造代码块执行");
    }
    
    public Example() {
        System.out.println("构造函数执行");
    }
}

静态代码块的作用范围

1. 类级别：静态代码块作用于类本身，与实例无关。
2. 执行时机：在类加载时执行，且只执行一次。
3. 访问权限：
   • 可以访问静态变量
   • 可以调用静态方法
   • 不能直接访问实例成员（因为此时可能还没有实例）

示例代码：

public class Example {
    // 静态变量
    private static int y;
    
    // 静态代码块
    static {
        y = 20;  // 可以访问静态变量
        System.out.println("静态代码块执行");
    }
    
    public Example() {
        System.out.println("构造函数执行");
    }
}

关键区别总结

特性	构造代码块	静态代码块
作用域	实例级别	类级别
执行次数	每次创建实例时执行	类加载时执行且仅一次
可访问成员	主要访问实例成员	主要访问静态成员
执行顺序	在构造函数前执行	在类加载时最先执行

---

构造代码块与静态代码块的内存分配区别

概念定义

1. 构造代码块：在类中直接使用 {} 定义的代码块，每次创建对象时都会执行，用于初始化对象的成员变量。
2. 静态代码块：使用 static {} 定义的代码块，仅在类加载时执行一次，用于初始化类的静态成员。

内存分配机制

构造代码块

• 内存分配时机：每次通过 new 创建对象时，随对象实例的分配而执行。
• 存储位置：代码块逻辑嵌入到每个构造方法中（编译后），实际占用的是堆内存中的对象实例空间。
• 生命周期：与对象实例绑定，对象被垃圾回收时，相关内存释放。

静态代码块

• 内存分配时机：类首次被加载到 JVM 时（如首次访问类、创建实例、调用静态方法等）。
• 存储位置：类元数据所在的方法区（Metaspace/JDK8+），属于类级别的资源。
• 生命周期：与类绑定，直到 JVM 卸载该类时才会释放（通常极少发生）。

关键区别对比表

特性	构造代码块	静态代码块
执行次数	每次 new 时执行	仅类加载时执行一次
内存区域	堆内存（对象实例）	方法区（类元数据）
初始化目标	对象实例成员	静态变量
线程安全性	依赖对象实例的线程访问控制	需额外同步控制（如并发场景）

示例代码

public class MemoryExample {
    // 静态代码块
    static {
        System.out.println("静态代码块执行：类加载时分配");
    }

    // 构造代码块
    {
        System.out.println("构造代码块执行：对象创建时分配");
    }

    public static void main(String[] args) {
        new MemoryExample(); // 第一次触发类加载和对象创建
        new MemoryExample(); // 仅触发对象创建
    }
}

输出结果

静态代码块执行：类加载时分配
构造代码块执行：对象创建时分配
构造代码块执行：对象创建时分配

注意事项

1. 静态代码块滥用：过多静态初始化可能导致类加载变慢，影响启动性能。
2. 构造代码块顺序：编译后会合并到所有构造方法头部，但优先级低于显式赋值的成员变量（如 private int x = 10;）。
3. 内存泄漏风险：
   • 静态代码块中持有大对象或全局引用会导致方法区压力。
   • 构造代码块中的未释放资源（如文件句柄）会随对象泄漏。

---

构造代码块与静态代码块在继承中的表现差异

构造代码块在继承中的表现

1. 执行顺序：

   • 在继承体系中，构造代码块的执行顺序遵循父类优先原则。
   • 具体顺序为：父类静态代码块 → 子类静态代码块 → 父类构造代码块 → 父类构造方法 → 子类构造代码块 → 子类构造方法。

2. 特点：

   • 每次创建子类对象时，父类的构造代码块都会被执行。
   • 构造代码块的内容会合并到每个构造方法的最开始位置。

3. 示例代码：

class Parent {
    {
        System.out.println("父类构造代码块");
    }
    
    public Parent() {
        System.out.println("父类无参构造");
    }
}

class Child extends Parent {
    {
        System.out.println("子类构造代码块");
    }
    
    public Child() {
        System.out.println("子类无参构造");
    }
}

// 测试输出：
// 父类构造代码块
// 父类无参构造
// 子类构造代码块
// 子类无参构造

静态代码块在继承中的表现

1. 执行顺序：

   • 静态代码块在类加载时执行，且只执行一次。
   • 继承体系中的执行顺序：父类静态代码块 → 子类静态代码块。

2. 特点：

   • 静态代码块的执行与对象实例化无关。
   • 即使创建多个子类对象，父类和子类的静态代码块都只会执行一次。

3. 示例代码：

class Parent {
    static {
        System.out.println("父类静态代码块");
    }
}

class Child extends Parent {
    static {
        System.out.println("子类静态代码块");
    }
}

// 测试输出（首次加载时）：
// 父类静态代码块
// 子类静态代码块

关键差异对比

特性	构造代码块	静态代码块
执行时机	每次实例化对象时	类首次加载时（仅一次）
继承中的执行顺序	在父类构造方法之后执行	在父类静态代码块之后执行
访问权限	可以访问实例成员	只能访问静态成员
执行次数	每次new对象都会执行	整个程序运行期间只执行一次

特殊场景分析

多级继承的情况

class GrandParent {
    static { System.out.println("祖父静态块"); }
    { System.out.println("祖父构造块"); }
}

class Parent extends GrandParent {
    static { System.out.println("父静态块"); }
    { System.out.println("父构造块"); }
}

class Child extends Parent {
    static { System.out.println("子静态块"); }
    { System.out.println("子构造块"); }
}

// 创建Child对象时的输出顺序：
// 祖父静态块 → 父静态块 → 子静态块
// 祖父构造块 → 父构造块 → 子构造块

注意事项

1. 静态代码块不能访问非静态成员
2. 构造代码块会在所有构造方法中重复执行
3. 如果父类没有无参构造方法，需要特别注意构造代码块的执行位置

---

构造代码块与静态代码块的使用场景对比

构造代码块的使用场景

1. 对象初始化通用逻辑
   当多个构造方法都需要执行相同的初始化代码时，可以避免在每个构造方法中重复编写。

2. 匿名内部类初始化
   匿名内部类无法定义构造方法，可通过构造代码块实现初始化逻辑。

3. 实例成员默认值增强
   在声明时无法通过简单赋值完成的复杂初始化（如集合填充）。

class User {
    private List<String> permissions;
    
    // 构造代码块：所有构造方法创建对象时都会执行
    {
        permissions = new ArrayList<>();
        permissions.add("basic_access"); // 所有用户默认拥有基础权限
    }
}

静态代码块的使用场景

1. 静态资源初始化
   加载配置文件、初始化静态工具类、建立数据库连接池等一次性操作。

2. 类加载时的验证
   在类被使用时进行环境检查（如检测必需的配置文件是否存在）。

3. 复杂静态变量初始化
   需要多行代码计算的静态常量初始化。

class ConfigLoader {
    static final Properties config;
    
    // 静态代码块：类加载时执行且仅执行一次
    static {
        config = new Properties();
        try (InputStream is = ConfigLoader.class.getResourceAsStream("/app.conf")) {
            config.load(is); // 加载配置文件
        } catch (IOException e) {
            throw new RuntimeException("配置文件加载失败", e);
        }
    }
}

关键对比维度

维度	构造代码块	静态代码块
执行时机	每次new对象时执行	类首次加载时执行（仅一次）
访问权限	可访问实例和静态成员	仅能访问静态成员
异常处理	可抛出检查异常	必须处理所有检查异常
继承影响	子类会隐式调用父类构造代码块	父类静态块优先于子类执行
线程安全	需考虑多线程实例化问题	类加载阶段天然线程安全

典型误区

1. 执行顺序混淆
   静态代码块（类加载）→ 父类构造代码块 → 子类构造代码块 → 构造方法

2. 静态代码块滥用
   在静态块中编写耗时操作会导致类加载阻塞。

3. 初始化循环依赖
   静态代码块间的相互调用可能导致NoClassDefFoundError。

// 错误示例：静态块循环依赖
class A {
    static { B.init(); }
}
class B {
    static { A.init(); }
}

---

四、综合应用

混合使用的执行顺序

在 Java 中，构造代码块、静态代码块和构造方法的混合使用涉及多个执行顺序的问题。理解它们的执行顺序对于编写正确的代码至关重要。

静态代码块的执行时机

静态代码块在类加载时执行，且仅执行一次。无论创建多少个对象，静态代码块都只会在第一次加载类时运行。

构造代码块的执行时机

构造代码块在每次创建对象时执行，且在构造方法之前执行。每次调用 new 关键字时，构造代码块都会运行。

构造方法的执行时机

构造方法在构造代码块之后执行，用于完成对象的初始化。

混合使用的执行顺序

当类中包含静态代码块、构造代码块和构造方法时，它们的执行顺序如下：

1. 静态代码块（类加载时执行，仅一次）
2. 构造代码块（每次创建对象时执行）
3. 构造方法（每次创建对象时执行）

示例代码

public class ExecutionOrderExample {
    // 静态代码块
    static {
        System.out.println("静态代码块执行");
    }

    // 构造代码块
    {
        System.out.println("构造代码块执行");
    }

    // 构造方法
    public ExecutionOrderExample() {
        System.out.println("构造方法执行");
    }

    public static void main(String[] args) {
        System.out.println("第一次创建对象：");
        new ExecutionOrderExample();

        System.out.println("\n第二次创建对象：");
        new ExecutionOrderExample();
    }
}

输出结果

静态代码块执行
第一次创建对象：
构造代码块执行
构造方法执行

第二次创建对象：
构造代码块执行
构造方法执行

关键点总结

1. 静态代码块在类加载时执行，且仅执行一次。
2. 构造代码块在每次创建对象时执行，且在构造方法之前。
3. 构造方法在构造代码块之后执行。

注意事项

• 如果类继承自父类，执行顺序会涉及父类和子类的静态代码块、构造代码块和构造方法。此时顺序会更复杂，需遵循继承的初始化规则。
• 静态代码块通常用于初始化静态变量或执行只需运行一次的代码（如加载配置文件）。
• 构造代码块适合用于多个构造方法的公共初始化逻辑。

---

实际开发中的应用案例

1. 初始化共享资源

静态代码块常用于初始化类级别的共享资源，例如数据库连接池、配置文件加载等。这些资源只需要在类加载时初始化一次，后续所有实例共享。

public class DatabaseConnection {
    private static ConnectionPool connectionPool;
    
    static {
        // 加载数据库驱动并初始化连接池
        try {
            Class.forName("com.mysql.jdbc.Driver");
            connectionPool = new ConnectionPool(10); // 初始化10个连接
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("数据库驱动加载失败", e);
        }
    }
    
    public static Connection getConnection() {
        return connectionPool.getConnection();
    }
}

2. 对象默认值设置

构造代码块适用于为所有构造方法设置共同的实例变量默认值，避免在每个构造方法中重复编写相同的初始化代码。

public class Employee {
    private String name;
    private String department;
    private Date hireDate;
    
    // 构造代码块：为所有Employee对象设置默认部门
    {
        department = "未分配部门";
        hireDate = new Date(); // 默认为当前日期
    }
    
    public Employee(String name) {
        this.name = name;
    }
    
    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }
}

3. 单例模式实现

静态代码块可以用于实现线程安全的单例模式，在类加载时就创建实例。

public class Singleton {
    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }
    
    private Singleton() {
        // 私有构造方法
    }
    
    public static Singleton getInstance() {
        return instance;
    }
}

4. 复杂对象初始化

当对象的初始化过程比较复杂时，可以使用构造代码块来保持构造方法的简洁。

public class ComplexObject {
    private Map<String, List<Integer>> dataMap;
    private Set<String> keySet;
    
    {
        // 复杂的初始化过程
        dataMap = new HashMap<>();
        keySet = new HashSet<>();
        
        // 从文件加载数据
        try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                String[] parts = line.split(":");
                String key = parts[0];
                List<Integer> values = Arrays.stream(parts[1].split(","))
                                          .map(Integer::parseInt)
                                          .collect(Collectors.toList());
                dataMap.put(key, values);
                keySet.add(key);
            }
        } catch (IOException e) {
            throw new RuntimeException("初始化失败", e);
        }
    }
    
    public ComplexObject() {
        // 构造方法保持简洁
    }
}

5. 日志记录器初始化

静态代码块常用于初始化日志记录器，这是大多数类都需要的基本功能。

public class ServiceClass {
    private static final Logger logger;
    
    static {
        logger = LoggerFactory.getLogger(ServiceClass.class);
        logger.info("ServiceClass 初始化完成");
    }
    
    // 类其他成员...
}

6. 枚举类型的初始化

静态代码块可以用于初始化枚举类型的附加属性。

public enum HttpStatus {
    OK(200, "OK"),
    NOT_FOUND(404, "Not Found"),
    SERVER_ERROR(500, "Internal Server Error");
    
    private final int code;
    private final String description;
    private static final Map<Integer, HttpStatus> codeMap = new HashMap<>();
    
    static {
        for (HttpStatus status : values()) {
            codeMap.put(status.code, status);
        }
    }
    
    HttpStatus(int code, String description) {
        this.code = code;
        this.description = description;
    }
    
    public static HttpStatus fromCode(int code) {
        return codeMap.get(code);
    }
}

7. 性能优化

在需要频繁创建对象且初始化过程耗时的情况下，可以使用静态代码块预先加载部分资源。

public class ImageProcessor {
    private static final ImageFilter[] filters;
    
    static {
        // 预先加载所有图像滤镜
        filters = new ImageFilter[10];
        for (int i = 0; i < filters.length; i++) {
            filters[i] = loadFilter(i); // 耗时的滤镜加载操作
        }
    }
    
    public Image process(Image image, int filterIndex) {
        return filters[filterIndex].apply(image);
    }
    
    private static ImageFilter loadFilter(int index) {
        // 实际的滤镜加载实现
    }
}

---

性能考虑与优化建议

1. 构造代码块的性能影响

1. 执行时机：构造代码块在每次创建对象时都会执行，若包含复杂逻辑或资源密集型操作，可能导致对象创建性能下降。
2. 重复初始化风险：若构造代码块与构造函数中存在重复初始化逻辑，会增加不必要的开销。

优化建议：

• 将只需执行一次的初始化逻辑移至静态代码块。
• 避免在构造代码块中执行耗时操作（如文件读取、网络请求）。

// 不推荐：每次构造都重复初始化
{
    this.cache = loadHeavyResource(); // 耗时操作
}

// 推荐：改用静态代码块（若资源可共享）
static {
    sharedCache = loadHeavyResource(); 
}

2. 静态代码块的性能影响

1. 类加载开销：静态代码块在类加载时执行，可能延长类加载时间，影响程序启动性能。
2. 线程安全：静态代码块默认是线程安全的，但若内部调用非线程安全代码，可能引发问题。

优化建议：

• 延迟初始化：使用静态内部类或Lazy Holder模式推迟静态资源的加载。
• 避免阻塞操作：不要在静态代码块中执行可能阻塞的操作（如等待锁）。

// 延迟初始化示例
class LazyResource {
    private static class Holder {
        static final Resource INSTANCE = loadResource();
    }
    static Resource getInstance() {
        return Holder.INSTANCE; // 首次调用时触发加载
    }
}

3. 常见性能陷阱

1. 循环依赖：静态代码块中引用其他类的静态变量可能导致类加载死锁。
2. 内存泄漏：静态代码块中持有对象引用可能导致无法被GC回收。

反例：

static {
    instance = new Singleton();
    instance.registerToGlobalManager(); // 若Manager也持有instance引用，导致内存泄漏
}

4. JVM层面的优化

1. 类加载优化：通过-XX:+TraceClassLoading监控静态代码块的加载时机。
2. JIT编译影响：高频执行的构造代码块可能被JIT优化，但过度复杂逻辑会阻碍优化。

5. 最佳实践总结

场景	建议
对象级初始化	优先使用构造函数，构造代码块保持简洁
类级耗时初始化	使用静态代码块+延迟加载机制
线程安全要求	在静态代码块中显式同步（如synchronized）
依赖其他类的静态资源	通过Class.forName()预加载依赖类

---

构造代码块与静态代码块

概念定义

1. 构造代码块（Instance Initialization Block）
   构造代码块是定义在类中、方法外的代码块，每次创建对象时都会执行，且在构造函数之前执行。
   语法格式：

   {
       // 构造代码块的内容
   }
   

2. 静态代码块（Static Initialization Block）
   静态代码块是使用 static 修饰的代码块，在类加载时执行，且仅执行一次。
   语法格式：

   static {
       // 静态代码块的内容
   }
   

使用场景

1. 构造代码块的使用场景

   • 用于初始化对象的公共属性，避免在每个构造函数中重复编写相同的代码。
   • 适合在多个构造函数中共享的初始化逻辑。

2. 静态代码块的使用场景

   • 用于初始化类的静态变量（如加载配置文件、数据库驱动等）。
   • 适合在类加载时执行一次性的初始化操作。

常见误区与注意事项

1. 构造代码块

   • 构造代码块会在 每次创建对象时执行，即使调用的是不同的构造函数。
   • 如果类中有多个构造代码块，它们会按照定义的顺序依次执行。
   • 构造代码块的执行顺序 先于构造函数。

2. 静态代码块

   • 静态代码块仅在 类加载时执行一次，即使创建多个对象也不会重复执行。
   • 静态代码块的执行顺序 先于构造代码块和构造函数。
   • 如果类继承自父类，静态代码块的执行顺序遵循 父类 -> 子类。

示例代码

public class BlockExample {
    static {
        System.out.println("静态代码块执行（类加载时执行一次）");
    }

    {
        System.out.println("构造代码块执行（每次创建对象时执行）");
    }

    public BlockExample() {
        System.out.println("构造函数执行");
    }

    public static void main(String[] args) {
        System.out.println("--- 第一次创建对象 ---");
        BlockExample obj1 = new BlockExample();

        System.out.println("--- 第二次创建对象 ---");
        BlockExample obj2 = new BlockExample();
    }
}

输出结果：

静态代码块执行（类加载时执行一次）
--- 第一次创建对象 ---
构造代码块执行（每次创建对象时执行）
构造函数执行
--- 第二次创建对象 ---
构造代码块执行（每次创建对象时执行）
构造函数执行

常见面试题解析

1. 构造代码块和静态代码块的执行顺序？

   • 静态代码块（类加载时） -> 构造代码块（对象创建时） -> 构造函数。

2. 静态代码块能否访问非静态成员？

   • 不能，因为静态代码块在类加载时执行，此时对象尚未创建，非静态成员还未初始化。

3. 构造代码块能否替代构造函数？

   • 不能，构造代码块用于共享初始化逻辑，但无法替代构造函数的参数传递功能。

4. 静态代码块能否抛出异常？

   • 可以，但必须捕获或声明为 throws，否则会导致类加载失败。

5. 如果类继承父类，静态代码块和构造代码块的执行顺序？

   • 静态代码块：父类 -> 子类（类加载阶段）。
   • 构造代码块：父类构造代码块 -> 父类构造函数 -> 子类构造代码块 -> 子类构造函数（对象创建阶段）。

---