Java 代码块详解：控制流、方法、实例、静态与同步代码块

while 循环代码块

int count = 0;
while (count < 3) { // 这是一个代码块，用于循环直到 count 等于 3
    System.out.println("计数：" + count);
    count++;
}

for 循环中的代码块

// 使用 for 循环打印 1 到 5 的数字
for (int i = 1; i <= 5; i++) { // 这是一个代码块，用于每次循环迭代
    System.out.println(i);
}

if-else 语句中的代码块

int score = 85;
if (score >= 90) { // 这是一个代码块，用于处理分数大于等于 90 的情况
    System.out.println("优秀");
} else { // 另一个代码块，用于处理分数小于 90 的情况
    System.out.println("良好");
}

3. 方法代码块

3.1 定义

方法代码块是方法体的具体实现，它定义了方法的行为。方法代码块以一对大括号 {} 开始和结束，位于方法声明之后。

方法代码块的主要作用是实现方法的逻辑。它包含了方法执行时需要执行的所有操作，比如变量声明、条件判断、循环、数据计算等。

3.2 示例及说明

public class ControlFlowInMethod {
    public static void main(String[] args) {
        // 调用方法并传递参数
        printMultiplesOfTen(5);
    }

    // 方法声明，用于打印 10 的倍数
    public static void printMultiplesOfTen(int count) {
        // 方法代码块开始
        for (int i = 1; i <= count; i++) {
            // 控制流语句的代码块
            if (i % 2 == 0) { // 检查是否为偶数
                System.out.println("10 * " + i + " = " + (10 * i));
            }
        }
        // 方法代码块结束
    }
}

在这个例子中，printMultiplesOfTen 方法用于打印 10 的倍数。

方法代码块中包含了一个 for 循环，这是一个 控制流语句的代码块。在 for 循环内部，还有一个 if 语句，它 也是一个控制流语句的代码块，用于检查当前的迭代次数 i 是否为偶数，如果是偶数，则打印出 10 乘以当前迭代次数的结果。

当 main 方法被调用时，它会调用 printMultiplesOfTen 方法，并传递一个参数 5，这意味着方法会打印出 10 的 1 倍到 5 倍的偶数倍数。

4. 实例代码块（构造代码块）

4.1 定义

实例初始化代码块（Instance Initializer Block），也简称为实例代码块，是在类体内部、方法外部定义的代码块，它不属于任何方法。实例初始化代码块主要用于初始化类的实例变量，可以看作是对象创建时的初始化设置。

它没有访问修饰符、返回类型、名称或参数列表，只有一对大括号 {} 包含的代码。

实例初始化代码块在对象被创建时执行，且在任何构造方法执行之前执行。如果有多个构造方法，实例初始化代码块在每个构造方法之前都会执行。

4.2 示例及说明

public class Example {
    int number;
    String name;

    // 实例初始化代码块
    {
        number = 10; // 初始化实例变量 number
        name = "Code 哈哈笑"; // 初始化实例变量 name
        System.out.println("实例代码块已经运行");
    }

    // 构造方法
    public Example() {
        System.out.println("构造函数已经被运行");
        System.out.println("--------------------------------");
        System.out.println("Constructor is called.");
    }

    public static void main(String[] args) {
        Example obj = new Example();
        System.out.println("Number: " + obj.number + ", Name: " + obj.name);
    }
}

在这个例子中，实例初始化代码块在对象 obj 被创建时执行，它初始化了 number 和 name 两个实例变量，并且会打印出被使用的消息。随后，当构造方法 Example() 被调用时，它会打印出构造方法被调用的信息。最后，在 main 方法中，我们可以看到对象的实例变量已经被初始化。

4.3 实例代码块与构造方法的区别

虽然 构造方法 和 实例代码块 都可以用于初始化对象，但它们之间存在一些区别：

1. 构造方法可以被重载（即一个类可以有多个构造方法），而实例代码块只能有一个。
2. 构造方法可以访问参数并使用 this 关键字调用其他构造方法，而实例代码块不能。
3. 实例代码块在任何构造方法执行之前执行，而构造方法在对象创建时执行。

5. 静态代码块

5.1 定义

静态代码块（Static Initializer Block），也称为静态初始化块，是 Java 类中的一个特殊代码块，它使用 static 关键字声明。静态代码块主要用于初始化类的静态变量或执行只需要执行一次的操作。

静态代码块定义在类的成员变量声明之后、方法定义之前。它使用 static 关键字标记，并且没有访问修饰符、返回类型、名称或参数列表，只有一对大括号 {} 包含的代码。

静态代码块在类被 Java 虚拟机（JVM）加载时执行，且仅执行一次。这意味着静态代码块的执行与类的任何对象的创建无关，它只与类的加载有关。

5.2 示例及说明

public class Example {
    static int staticNumber;
    static String staticName;

    // 静态代码块
    static {
        staticNumber = 10; // 初始化静态变量 staticNumber
        staticName = "Code 哈哈笑"; // 初始化静态变量 staticName
        System.out.println("Static block is executed.");
    }

    public static void main(String[] args) {
        System.out.println("Static number: " + staticNumber);
        System.out.println("Static name: " + staticName);
    }
}

在这个例子中，静态代码块在 Example 类被加载时执行，它初始化了两个静态变量 staticNumber 和 staticName，并打印了一条消息。当 main 方法被调用时，它打印出这两个静态变量的值。

5.3 静态代码块与构造方法的区别

静态代码块与构造方法的主要区别在于：

1. 静态代码块用于初始化静态变量，而构造方法用于初始化实例变量。
2. 静态代码块在类加载时执行，而构造方法在对象创建时执行。
3. 静态代码块中的代码不能访问类的实例变量或调用实例方法，因为这些实例成员依赖于具体的对象实例。

5.4 使用场景

静态代码块适用于以下场景：

1. 初始化静态常量。
2. 执行只需要执行一次的资源密集型操作，如加载配置文件、连接数据库等。
3. 在类加载时执行一些必要的初始化操作，这些操作与任何对象的创建无关。

6. 同步代码块

6.1 定义

同步代码块（Synchronized Block）是 Java 中用于实现线程同步的一种机制。它允许多个线程在访问共享资源时，保证同一时间只有一个线程可以执行特定的代码段，从而避免发生线程安全问题，如数据不一致、竞态条件等。

同步代码块可以通过 synchronized 关键字来定义。它可以出现在任何方法中，或者作为一个独立的代码块出现在方法内部。当使用 synchronized 关键字时，你需要指定一个锁对象（lock object），代码块内的代码只有在获得该对象的锁之后才能执行。

同步代码块的主要作用是确保在多线程环境中，当一个线程访问同步代码块时，其他线程将被阻塞，直到锁被释放。这样可以防止多个线程同时修改同一个资源，确保数据的一致性和线程安全。

6.2 示例及说明

public class Example {
    private static final Object lock = new Object();

    public void methodOne() {
        synchronized (lock) { // 同步代码块
            System.out.println("Method One is executing.");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method One finished.");
        }
    }

    public void methodTwo() {
        synchronized (lock) { // 同步代码块
            System.out.println("Method Two is executing.");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method Two finished.");
        }
    }

    public static void main(String[] args) {
        final Example example = new Example();
        Thread threadOne = new Thread(() -> example.methodOne());
        Thread threadTwo = new Thread(() -> example.methodTwo());
        threadOne.start();
        threadTwo.start();
    }
}

在这个例子中，methodOne 和 methodTwo 都包含了一个同步代码块，它们使用相同的锁对象 lock。当 main 方法启动两个线程时，它们将尝试执行这两个方法。由于同步代码块使用了相同的锁对象，所以这两个方法不会同时执行，从而避免了线程安全问题。

6.3 同步代码块与同步方法的区别

同步代码块与同步方法的主要区别在于：

1. 同步方法使用 synchronized 关键字修饰整个方法，而同步代码块只同步方法中的特定部分。
2. 同步代码块允许更细粒度的控制，你可以只同步需要同步的部分，而不是整个方法。

同步代码块适用于以下场景：

1. 当只需要同步方法中的一小部分代码时。
2. 当多个方法需要同步同一个资源，但不是整个方法时。
3. 当需要提高性能，减少不必要的同步开销时。

7. 实例代码块（构造代码块）、静态代码块和构造函数的运行顺序

7.1 在同一个类中

public class Example {
    // 静态代码块
    static {
        System.out.println("静态代码块已经运行");
    }

    // 实例初始化代码块
    {
        System.out.println("实例代码块已经运行");
    }

    // 构造方法
    public Example() {
        System.out.println("构造函数已经被运行");
    }

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

运行结果：

有同学疑问，运行顺序是不是和代码块写的顺序有关呢？

那打乱顺序再次运行：

public class Example {
    // 构造方法
    public Example() {
        System.out.println("构造函数已经被运行");
    }

    // 实例初始化代码块
    {
        System.out.println("实例代码块已经运行");
    }

    // 静态代码块
    static {
        System.out.println("静态代码块已经运行");
    }

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

显然，代码块运行的顺序和代码块的位置无关，先运行静态代码块，再运行实例代码块，最后运行构造函数。

7.2 在继承关系中

同学们思考一下将会打印出什么呢？

class Father {
    static {
        System.out.println("父类的静态代码块");
    }
    {
        System.out.println("父类的实例代码块");
    }
    public Father() {
        System.out.println("父类的构造函数");
    }
}

public class Son extends Father {
    static {
        System.out.println("子类的静态代码块");
    }
    {
        System.out.println("子类的实例代码块");
    }
    public Son() {
        //super();
        System.out.println("子类的构造函数");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}

运行结果

下面的代码又会打印出什么呢？是不是上面的内容打印两边呢？

class Father {
    static {
        System.out.println("父类的静态代码块");
    }
    {
        System.out.println("父类的实例代码块");
    }
    public Father() {
        System.out.println("父类的构造函数");
    }
}

public class Son extends Father {
    static {
        System.out.println("子类的静态代码块");
    }
    {
        System.out.println("子类的实例代码块");
    }
    public Son() {
        //super();
        System.out.println("子类的构造函数");
    }

    public static void main(String[] args) {
        Son son1 = new Son();
        System.out.println("=======================");
        Son son2 = new Son();
    }
}

打印结果：

8. 练习题

下面的代码运行后会发生什么？

public class Test {
    public int aMethod() {
        static int i = 0;
        i++;
        return i;
    }

    public static void main(String args[]) {
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println(j);
    }
}

答：D 解析：局部代码块中不能有静态变量。只有成员变量才能是静态变量。

下列代码运行后会输出什么？

public class Test {
    static int cnt = 6;
    static {
        cnt += 9;
    }

    public static void main(String args[]) {
        System.out.println("cnt = " + cnt);
    }

    static {
        cnt /= 3;
    }
}

答案：A 解析： （1）静态变量初始化：static int cnt = 6; 在类加载时进行初始化，因此 cnt 的初始值为 6。 （2）第一个静态代码块先被执行。在第一个静态代码块中，cnt 的值被增加了 9，即：cnt = 6 + 9 = 15。 （3）紧接着，第二个静态代码块执行，此时 cnt = 15。在第二个静态代码块中，cnt 的值被除以 3，即：cnt = 15 / 3 = 5。