局部内部类

如果一个类只在某个方法内部使用一次，且逻辑相对复杂不适合用匿名内部类，局部内部类就是解决方案。

基本定义

定义在方法或代码块内的类：

public class Outer {

    public void method() {
        // 局部内部类（在方法内定义）
        class LocalInner {
            private String localField = "局部内部类字段";

            public void display() {
                System.out.println(localField);
            }
        }

        // 只在这里可用
        LocalInner inner = new LocalInner();
        inner.display();
    }
}

访问外部成员

局部内部类可以访问外部类的所有成员，以及方法中的局部变量（必须是 effectively final）：

public class Outer {
    private int outerField = 100;

    public void method() {
        int localVar = 200;  // effectively final

        class LocalInner {
            public void display() {
                // ✅ 访问外部类成员
                System.out.println(outerField);
                // ✅ 访问局部变量
                System.out.println(localVar);
            }
        }

        new LocalInner().display();
    }
}

作用域限制

局部内部类只在定义它的方法或代码块内可见：

public class ScopeDemo {

    public void methodA() {
        class LocalInner {
            void display() {
                System.out.println("Method A's inner class");
            }
        }
        new LocalInner().display(); // ✅ 这里可用
    }

    public void methodB() {
        // LocalInner inner = new LocalInner(); // ❌ 编译错误：不在作用域内
    }
}

在代码块内定义

public class BlockScopeDemo {

    public static void main(String[] args) {
        // 在代码块内定义
        {
            class BlockInner {
                void say() {
                    System.out.println("Hello from block inner class");
                }
            }
            new BlockInner().say(); // ✅ 在块内可用
        }

        // new BlockInner().say(); // ❌ 超出作用域
    }
}

实际应用：策略模式中的局部类

public class StrategyDemo {

    public void processData() {
        // 根据条件选择处理策略
        boolean useAdvanced = true;

        // 局部内部类定义策略
        class SimpleProcessor implements Processor {
            @Override
            public void process(String data) {
                System.out.println("Simple: " + data);
            }
        }

        class AdvancedProcessor implements Processor {
            @Override
            public void process(String data) {
                System.out.println("Advanced: " + data.toUpperCase());
            }
        }

        // 使用策略
        Processor processor = useAdvanced ? new AdvancedProcessor() : new SimpleProcessor();
        processor.process("hello");
    }

    interface Processor {
        void process(String data);
    }
}

注意事项

1. 作用域受限：只在其定义的方法或代码块内可见
2. 可访问外部所有成员：外部类成员 + 方法中的 effectively final 局部变量
3. JDK 8+ 特性：局部变量不需要显式声明 final，只要不被修改即可访问
4. 适合复杂逻辑：当匿名内部类逻辑过于复杂时，用局部内部类更清晰
5. 不能有 static 修饰：局部内部类不能有 static 成员（JDK 16+ 允许 static 局部变量）