什么是局部变量？

要明确什么是“局部变量”（Local Variable）。

局部变量是指在方法、构造方法或代码块内部声明的变量，它的作用域仅限于声明它的那个代码块。

示例：

public class LocalVariableExample {
    public void myMethod() {
        // i 就是一个局部变量
        int i = 10; 
        if (true) {
            // j 也是一个局部变量，作用域仅在 if 代码块内
            String j = "Hello"; 
            System.out.println(j); // 有效
        }
        System.out.println(i);    // 有效
        // System.out.println(j); // 编译错误！'j' cannot be resolved to a variable
    }
}

final 关键字的作用

final 是 Java 中的一个关键字，意思是“最终的”、“不可变的”，当它用来修饰一个局部变量时，核心作用就是：一旦被赋值，就不能再被修改。

你可以把它想象成一个“只读”变量，或者一个常量（尽管 Java 中有更严格的 static final 用于全局常量）。

final 局部变量的核心规则

使用 final 修饰局部变量时，必须遵守以下两条核心规则：

必须进行初始化

final 局部变量必须在声明时、或者在构造方法/代码块执行完毕之前被显式初始化，否则，编译器会报错。

示例（错误）：

public class FinalLocalError {
    public void myMethod() {
        final int number; // 声明了一个 final 局部变量，但没有初始化
        // ... 其他代码 ...
        number = 100;    // 编译错误！可能尚未初始化变量 number
        System.out.println(number);
    }
}

示例（正确）：

public class FinalLocalCorrect {
    public void myMethod() {
        // 方式一：声明时直接初始化
        final int number = 100;
        // number = 200; // 编译错误！无法为最终变量 number 指定值
        // 方式二：先声明，在使用前初始化
        final String message;
        message = "Hello, Java!";
        System.out.println(message);
        // message = "New Message"; // 编译错误！
    }
}

只能被赋值一次

final 局部变量在初始化之后，任何试图修改其值的操作都会导致编译错误。

示例（错误）：

public class FinalReassignError {
    public void myMethod() {
        final double PI = 3.14159;
        PI = 3.14; // 编译错误！无法为最终变量 PI 指定值
    }
}

final 局部变量的应用场景

为什么我们要使用 final 局部变量？主要有以下几个好处：

增强代码可读性和意图性

当一个变量被声明为 final，阅读代码的开发者会立刻明白：这个变量在初始化后就不会改变，这减少了认知负担，不需要去追踪这个变量在整个方法中是否会被修改。

示例：

public void processOrder(String orderId) {
    // 不使用 final，意图不明确
    String status = "PENDING";
    // ... 100 行代码后 ...
    status = "SHIPPED"; // 读者需要回看才能知道 status 被修改了
    // 使用 final，意图清晰
    final String orderStatus = "PENDING";
    // ... 100 行代码后 ...
    // 读者知道 orderStatus 的值永远是 "PENDING"，不会被修改
    log.info("Order " + orderId + " is in status: " + orderStatus);
}

在匿名内部类中访问局部变量（闭包）

这是 final 局部变量一个非常重要的应用，在 Java 8 之前，如果一个局部变量要在匿名内部类（Anonymous Inner Class）中被使用，那么这个局部变量必须被声明为 final。

从 Java 8 开始，这个规则有所放宽，编译器会隐式地将“事实上是 final”的变量视为 final（即你虽然不写 final，但代码中也只给它赋值一次），但为了代码清晰和兼容性，显式声明为 final 仍然是最佳实践。

示例（在多线程或事件监听器中常见）：

public class ButtonHandler {
    public void setClickListener() {
        // button 是一个成员变量
        Button button = new Button("Click Me");
        final String buttonText = "Button was clicked!"; // 必须是 final (或事实上的 final)
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 在匿名内部类中，我们访问了外部的局部变量 buttonText
                // buttonText 没有 final 修饰，在 Java 8 之前会编译报错
                System.out.println(buttonText);
            }
        });
        // button.setText("New Text"); // 如果这行代码存在，buttonText 就不是 "事实上的 final" 了
    }
}

为什么需要这个规则？ 因为匿名内部类的对象可能会在其外部方法执行完毕后仍然存活（被其他线程持有），如果允许修改局部变量，就会导致一个非常危险的局面：外部方法已经结束，局部变量的生命周期本应结束，但内部类对象却持有一个对它的引用，并试图修改一个“已死亡”的变量。final 关键字从根本上杜绝了这种可能性，确保了线程安全和数据一致性。

确保 switch 语句的 case 分支常量

在 switch 语句中，case 标签后的值必须是常量表达式。final 局部变量满足这个条件。

public void switchExample(int day) {
    final int MONDAY = 1;
    final int TUESDAY = 2;
    switch (day) {
        case MONDAY: // 正确，MONDAY 是 final 常量
            System.out.println("Monday");
            break;
        case TUESDAY: // 正确
            System.out.println("Tuesday");
            break;
        default:
            System.out.println("Other day");
    }
}

final 局部变量 vs. final 成员变量

这是一个常见的混淆点,简单对比一下：

• 定义：final 局部变量是声明在方法、构造方法或代码块内部的变量。
• 核心规则：
  1. 必须初始化：在使用前必须被赋值一次。
  2. 不可再赋值：初始化后，其值不能再被修改。
• 主要优点：
  1. 提高可读性：明确表示变量是“常量”。
  2. 增强安全性：特别是在匿名内部类中，可以防止数据被意外修改，保证了线程安全。
  3. 用于 switch 语句：作为 case 标签的常量。
• 最佳实践：当你确定一个局部变量在初始化后不需要改变时，就应该习惯性地使用 final 来修饰它，这是一种优秀的编码习惯。