编辑“︁Java代码块”︁

= Java代码块 =

'''Java代码块'''（Code Block）是Java程序中用大括号<code>{}</code>包裹的一段代码，用于限定变量的作用域或控制代码的执行顺序。代码块在Java中分为多种类型，包括'''实例初始化块'''、'''静态初始化块'''、'''局部代码块'''和'''同步代码块'''。理解代码块的作用对于掌握Java面向对象编程至关重要。

== 代码块的类型 ==

Java中的代码块主要分为以下四种类型：

=== 1. 实例初始化块（Instance Initialization Block） ===
实例初始化块在每次创建类的实例时执行，用于初始化实例变量。它在构造函数之前运行。

==== 示例 ====
<syntaxhighlight lang="java">
public class Example {
    // 实例变量
    int x;

    // 实例初始化块
    {
        x = 10;
        System.out.println("实例初始化块执行，x = " + x);
    }

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

    public static void main(String[] args) {
        Example obj = new Example();
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
实例初始化块执行，x = 10
构造函数执行
</pre>

=== 2. 静态初始化块（Static Initialization Block） ===
静态初始化块在类加载时执行，用于初始化静态变量。它只执行一次，优先于实例初始化块和构造函数。

==== 示例 ====
<syntaxhighlight lang="java">
public class Example {
    // 静态变量
    static int y;

    // 静态初始化块
    static {
        y = 20;
        System.out.println("静态初始化块执行，y = " + y);
    }

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

    public static void main(String[] args) {
        Example obj1 = new Example();
        Example obj2 = new Example(); // 静态块不会再次执行
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
静态初始化块执行，y = 20
构造函数执行
构造函数执行
</pre>

=== 3. 局部代码块（Local Block） ===
局部代码块用于限定变量的作用域，通常出现在方法或语句中。

==== 示例 ====
<syntaxhighlight lang="java">
public class Example {
    public void display() {
        int a = 5;
        System.out.println("a = " + a);

        // 局部代码块
        {
            int b = 10;
            System.out.println("b = " + b);
        }

        // System.out.println(b); // 错误：b超出作用域
    }

    public static void main(String[] args) {
        Example obj = new Example();
        obj.display();
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
a = 5
b = 10
</pre>

=== 4. 同步代码块（Synchronized Block） ===
同步代码块用于多线程编程，确保同一时间只有一个线程访问共享资源。

==== 示例 ====
<syntaxhighlight lang="java">
public class Counter {
    private int count = 0;

    public void increment() {
        // 同步代码块
        synchronized (this) {
            count++;
            System.out.println("Count: " + count);
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
    }
}
</syntaxhighlight>

==== 输出示例 ====
<pre>
Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Count: 6
Count: 7
Count: 8
Count: 9
Count: 10
</pre>

== 代码块的执行顺序 ==
Java中代码块的执行顺序遵循以下规则：
1. 静态初始化块（类加载时执行一次）
2. 实例初始化块（每次创建对象时执行）
3. 构造函数
4. 局部代码块（在方法或语句中按顺序执行）

=== 执行顺序示例 ===
<syntaxhighlight lang="java">
public class ExecutionOrder {
    static {
        System.out.println("静态初始化块");
    }

    {
        System.out.println("实例初始化块");
    }

    public ExecutionOrder() {
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        System.out.println("main方法开始");
        ExecutionOrder obj1 = new ExecutionOrder();
        ExecutionOrder obj2 = new ExecutionOrder();
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
静态初始化块
main方法开始
实例初始化块
构造函数
实例初始化块
构造函数
</pre>

== 实际应用场景 ==

=== 1. 资源初始化 ===
静态代码块常用于初始化静态资源，如数据库连接池或配置文件加载。

<syntaxhighlight lang="java">
public class DatabaseConfig {
    private static Properties config;

    static {
        config = new Properties();
        try (InputStream input = DatabaseConfig.class.getResourceAsStream("/config.properties")) {
            config.load(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String getConfig(String key) {
        return config.getProperty(key);
    }
}
</syntaxhighlight>

=== 2. 单例模式 ===
静态代码块可用于实现线程安全的单例模式。

<syntaxhighlight lang="java">
public class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}
</syntaxhighlight>

=== 3. 性能优化 ===
局部代码块可用于限制变量的作用域，减少内存占用。

<syntaxhighlight lang="java">
public void processLargeData() {
    // 大数据处理
    {
        byte[] largeData = new byte[1024 * 1024 * 100]; // 100MB
        // 处理数据...
    }
    // largeData超出作用域，可被垃圾回收
    // 继续其他操作...
}
</syntaxhighlight>

== 常见问题 ==

=== 1. 静态代码块 vs 实例代码块 ===
静态代码块在类加载时执行一次，而实例代码块在每次创建对象时执行。

=== 2. 代码块与构造函数的区别 ===
代码块用于通用的初始化逻辑，而构造函数用于特定对象的初始化。代码块中的逻辑会被所有构造函数共享。

=== 3. 代码块的嵌套 ===
代码块可以嵌套，内层代码块中的变量作用域仅限于该代码块。

<syntaxhighlight lang="java">
public class NestedBlocks {
    public static void main(String[] args) {
        int x = 10;
        {
            int y = 20;
            System.out.println(x + y); // 正确
        }
        // System.out.println(y); // 错误：y超出作用域
    }
}
</syntaxhighlight>

== 总结 ==
Java代码块是组织和管理代码的重要工具，不同类型的代码块有不同的用途和执行时机：
* 静态代码块：类加载时执行，用于静态资源初始化
* 实例代码块：对象创建时执行，用于实例变量初始化
* 局部代码块：限定变量作用域，优化内存使用
* 同步代码块：控制多线程访问共享资源

理解并合理使用代码块可以使Java程序更加结构清晰、高效可靠。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java面向对象基础]]