boolean 是 Java 中一种基本数据类型，它只有两个可能的值：true 和 false。

局部变量的初始化

在方法、构造函数或代码块中声明的变量被称为局部变量。

核心规则：必须显式初始化

Java 编译器有一个非常重要的规则：局部变量必须在使用前被显式初始化，如果你声明了一个 boolean 局部变量但没有给它赋值，编译器会报错。

错误示例：

public class Test {
    public static void main(String[] args) {
        // 声明一个 boolean 局部变量，但没有初始化
        boolean flag; 
        // 尝试使用未初始化的变量，会导致编译错误
        if (flag) { // 错误：可能尚未初始化变量 flag
            System.out.println("flag is true");
        }
    }
}

编译错误信息：

error: variable flag might not have been initialized
        if (flag) {
           ^

正确的初始化方式

你可以通过以下几种方式正确初始化一个 boolean 局部变量：

a) 直接赋值

这是最直接的方式,在声明时就给出初始值。

public class Test {
    public static void main(String[] args) {
        // 声明并初始化为 true
        boolean isLoggedIn = true;
        // 声明并初始化为 false
        boolean hasError = false;
        System.out.println("Is Logged In: " + isLoggedIn); // 输出: Is Logged In: true
        System.out.println("Has Error: " + hasError);     // 输出: Has Error: false
    }
}

b) 声明后赋值

你也可以先声明变量,然后在后续的代码中为其赋值。

public class Test {
    public static void main(String[] args) {
        boolean isActive;
        // 后续根据条件赋值
        int userStatus = 1; // 假设 1 表示激活
        if (userStatus == 1) {
            isActive = true;
        } else {
            isActive = false;
        }
        System.out.println("Is Active: " + isActive); // 输出: Is Active: true
    }
}

c) 表达式初始化

boolean 变量的值可以是一个返回 boolean 结果的表达式。

public class Test {
    public static void main(String[] args) {
        int age = 20;
        // 表达式 (age >= 18) 的结果是 true 或 false，用于初始化 isAdult
        boolean isAdult = (age >= 18); 
        System.out.println("Is Adult: " + isAdult); // 输出: Is Adult: true
    }
}

成员变量的初始化（实例变量和类变量）

在类中,但在方法、构造函数或代码块之外声明的变量被称为成员变量，它们分为实例变量和类变量（静态变量）。

核心规则：默认初始化

与局部变量不同,成员变量（无论是实例变量还是类变量）如果不显式初始化，Java 会自动为其提供一个默认值。

实例变量 的初始化

实例变量属于对象,每个对象都有一份独立的副本。

a) 不显式初始化（使用默认值）

public class Car {
    // 实例变量，没有显式初始化
    boolean isEngineRunning; 
    String model;
    public void startEngine() {
        // isEngineRunning 的默认值是 false
        if (!isEngineRunning) {
            System.out.println("Starting the engine of " + model + "..."); // model 的默认值是 null
            isEngineRunning = true;
        }
    }
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.startEngine(); 
        // 输出: Starting the engine of null...
    }
}

b) 显式初始化（声明时赋值）

public class Car {
    // 实例变量，在声明时显式初始化
    boolean isEngineRunning = false; 
    String model = "Tesla Model 3";
    public void startEngine() {
        if (!isEngineRunning) {
            System.out.println("Starting the engine of " + model + "...");
            isEngineRunning = true;
        }
    }
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.startEngine();
        // 输出: Starting the engine of Tesla Model 3...
    }
}

c) 在构造函数中初始化

这是最常见和推荐的初始化实例变量的方式,因为它可以在创建对象时根据传入的参数来设置不同的值。

public class User {
    String username;
    boolean isActive;
    // 构造函数，用于初始化实例变量
    public User(String username, boolean isActive) {
        this.username = username;
        this.isActive = isActive;
    }
    public void printStatus() {
        System.out.println("User: " + username + ", Active: " + isActive);
    }
    public static void main(String[] args) {
        User user1 = new User("Alice", true);
        User user2 = new User("Bob", false);
        user1.printStatus(); // 输出: User: Alice, Active: true
        user2.printStatus(); // 输出: User: Bob, Active: false
    }
}

类变量（静态变量）的初始化

类变量用 static 关键字修饰，属于类本身，所有对象共享同一个副本，它的初始化规则与实例变量类似，但初始化时机更早（在类加载时）。

a) 不显式初始化（使用默认值）

public class Counter {
    // 类变量，共享计数
    static boolean isCounting; // 默认值为 false
    private static int count = 0;
    public static void increment() {
        if (!isCounting) {
            isCounting = true;
        }
        count++;
    }
    public static void printCount() {
        System.out.println("Counting is " + isCounting + ", Total count: " + count);
    }
    public static void main(String[] args) {
        Counter.printCount(); // 输出: Counting is false, Total count: 0
        Counter.increment();
        Counter.printCount(); // 输出: Counting is true, Total count: 1
    }
}

b) 显式初始化（声明时赋值）

public class Config {
    // 类变量，在声明时显式初始化
    static boolean debugMode = true;
    static String version = "1.0.0";
    public static void showConfig() {
        System.out.println("Debug Mode: " + debugMode);
        System.out.println("Version: " + version);
    }
    public static void main(String[] args) {
        Config.showConfig();
        // 输出:
        // Debug Mode: true
        // Version: 1.0.0
    }
}

c) 在静态初始化块中初始化

当一个静态变量的初始化过程比较复杂（需要多行代码或异常处理）时，可以使用静态初始化块。

public class DatabaseConfig {
    static boolean isConnected;
    static String connectionUrl;
    // 静态初始化块，在类加载时执行一次
    static {
        System.out.println("Initializing database configuration...");
        try {
            // 模拟复杂的初始化过程
            connectionUrl = "jdbc:mysql://localhost:3306/mydb";
            isConnected = true; // 假设连接成功
        } catch (Exception e) {
            isConnected = false;
            connectionUrl = "N/A";
        }
    }
    public static void printStatus() {
        System.out.println("Connection URL: " + connectionUrl);
        System.out.println("Is Connected: " + isConnected);
    }
    public static void main(String[] args) {
        DatabaseConfig.printStatus();
        // 输出:
        // Initializing database configuration...
        // Connection URL: jdbc:mysql://localhost:3306/mydb
        // Is Connected: true
    }
}