局部类：在方法内部的声明

1. 局部类

局部类——是指在方法内部（甚至在代码块内部，例如循环或 if 块）声明的类。它只在该方法内部可见和可用，离开该方法的作用域——就仿佛它从未存在过。与匿名类不同，局部类有名字（哪怕很简单），可以包含多个方法，甚至字段。

打个比方——想象你在按食谱烹饪一道复杂的菜。在某个步骤中你需要做一种只在这道菜里用到的特殊酱汁。与其为这个酱汁单独出版一本食谱，你会在主食谱里直接写出它的做法。局部类的工作方式完全一样——它是“食谱里的食谱”，只在某个具体方法中需要。

局部类的声明示例

public class Outer {
    void someMethod() {
        class Local {
            void print() {
                System.out.println("Hello from Local!");
            }
        }
        Local local = new Local();
        local.print();
    }
}

这里，类 Local 在 Outer 类的 someMethod 方法内部声明。它只存在于这个方法中，外部不可见。

局部类的语法

局部类的声明与普通类类似，只是它发生在方法内部：

void myMethod() {
    class MyLocalClass {
        void doSomething() {
            System.out.println("本地类正在工作！");
        }
    }

    MyLocalClass obj = new MyLocalClass();
    obj.doSomething();
}

语法要点：

• 可以在任何方法、构造器或甚至初始化块中声明局部类。
• 局部类必须有名称（不同于匿名类）。
• 局部类不能使用访问修饰符（public、private、protected）或 static 修饰符。
• 局部类可以实现接口或继承其他类。

类的几种形式对比:

public class Example {
// 1. 普通类（在单独文件中）
// class RegularClass { ... }

    // 2. 内部类（在类中）
    class InnerClass { }
    
    // 3. 静态嵌套类（在类中）
    static class NestedClass { }
    
    void method() {
        // 4. 局部类（在方法中）
        class LocalClass { }
        
        // 5. 匿名类（在方法中，无名称）
        Object obj = new Object() { };
    }
}

局部类 = 仅供该方法使用的有名类！

2. 局部类的特性

对方法变量的访问

局部类可以访问：

• 外部类的字段（即使它们是 private）。
• 仅限外围方法中 final 或 effectively final 的变量。

什么是“effectively final”？
是指变量在初始化后其值不再发生改变。例如：

void foo() {
    int x = 5; // effectively final
    class L { void print() { System.out.println(x); } }
}

如果你稍后写下 x = 10;，编译器就会报错。

为什么会这样？

这与 Java 在“幕后”实现局部类的方式有关：方法变量实际上会被复制到局部类中，而不是通过引用保存。若变量还能变化，局部类可能会使用到过期的副本——这会带来缺陷与麻烦。

访问变量的示例

public class Outer {
    private String secret = "秘密！";

    void revealSecret() {
        String greeting = "你好，"; // effectively final

        class Revealer {
            void printSecret() {
                System.out.println(greeting + " " + secret);
            }
        }

        Revealer revealer = new Revealer();
        revealer.printSecret();
    }
}

3. 局部类的应用：为什么以及何时使用？

局部类不是每天都会用到的工具，但在某些时候它能让代码更简洁、更紧凑。以下场景值得使用：

• 仅用于某个方法的辅助逻辑。
  例如，在方法中实现复杂的排序、过滤或临时数据结构。
• 封装以免“污染”类的命名空间。
  如果某个类只在一个地方用到，没有必要让它在整个类或包中可见。
• 实现一些设计模式时，辅助对象只需要局部存在。

示例：用局部类进行排序

假设你有一个姓名列表，希望按照长度排序。可以创建一个局部类比较器：

import java.util.*;

public class NameSorter {
    public void sortNames(List<String> names) {
        class LengthComparator implements Comparator<String> {
            @Override
            public int compare(String a, String b) {
                return Integer.compare(a.length(), b.length());
            }
        }
        Collections.sort(names, new LengthComparator());
    }
}

示例：临时结构

有时需要在某个方法中创建一个辅助结构来处理数据：

void processScores(int[] scores) {
    class ScoreInfo {
        int score;
        boolean passed;

        ScoreInfo(int score) {
            this.score = score;
            this.passed = score >= 60;
        }
    }

    for (int s : scores) {
        ScoreInfo info = new ScoreInfo(s);
        System.out.println("分数: " + info.score + ", 通过: " + info.passed);
    }
}

4. 局部类 vs. 匿名类

有时会问：既然有匿名类，还需要局部类吗？我们来分析一下。

• 局部类——有名称，可以在一个方法内复用，能添加字段、多个方法、甚至再嵌套类。
• 匿名类——没有名称，通常是接口或父类的“一次性实现”，一般只重写一两个方法。

何时使用：

• 如果逻辑简单且只用一次——用匿名类。
• 如果需要更多方法或字段，或要在同一方法里多处使用——用局部类。

对比示例

匿名类：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("快速且匿名！");
    }
};

局部类：

void doWork() {
    class MyWorker implements Runnable {
        @Override
        public void run() {
            System.out.println("我是局部类！");
        }
    }
    MyWorker worker = new MyWorker();
    worker.run();
}

5. 局部类的限制和注意事项

• 访问修饰符： 局部类不能被声明为 public、private 或 protected，也不能添加 static。
• 静态成员： 局部类不能包含静态成员，除非是常量（static final）。
• 可见范围： 局部类只在其声明的代码块内可见。
• 使用泛型参数： 必要时，局部类也可以是泛型的。
• 嵌套： 可以在局部类内部再声明局部类（但不建议滥用，否则代码会像“套娃”）。

6. 在真实应用中的局部类

继续我们的教学应用。假设有一个 Quiz 类，它向用户提问并检查答案。我们希望在校验的方法内部创建一个临时类，用来保存用户的回答和值得否正确的状态。

示例：在应用中使用局部类

import java.util.Scanner;

public class Quiz {
    private String question = "法国的首都？";
    private String correctAnswer = "巴黎";

    public void runQuiz() {
        Scanner scanner = new Scanner(System.in);

        System.out.println(question);
        String userAnswer = scanner.nextLine();

        // 用于保存结果的局部类
        class AnswerResult {
            String answer;
            boolean isCorrect;

            AnswerResult(String answer) {
                this.answer = answer;
                this.isCorrect = answer.equalsIgnoreCase(correctAnswer);
            }

            void printResult() {
                if (isCorrect) {
                    System.out.println("正确！");
                } else {
                    System.out.println("不正确，正确答案：" + correctAnswer);
                }
            }
        }

        AnswerResult result = new AnswerResult(userAnswer);
        result.printResult();
    }
}

这里，类 AnswerResult 只存在于方法 runQuiz 内部，其他地方都不需要。这是局部类在实践中的一个很好的示例！

7. 使用局部类的常见错误

错误 № 1：试图访问不是 final 或不是 effectively final 的方法变量。
如果你在方法里声明了一个变量，并在局部类中使用了它，而后又修改了它的值，编译器会立刻报错。务必确保此类变量在初始化后不再改变。

错误 № 2：尝试添加访问修饰符或 static。
局部类不能使用 public、private、protected 或 static 修饰。如果这样做——编译器会拒绝。

错误 № 3：尝试在方法外使用局部类。
局部类只在其声明的方法（或代码块）中存活。在其他方法或类外部均不可见。

错误 № 4：用局部类承载过于复杂的逻辑。
如果你的局部类变得太大，包含许多方法或字段——多半应该把它提取成独立的类。局部类更适合紧凑的、辅助性的任务。