day2_605：局部内部类 :)-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_73217694/article/details/145525175

可以给我一个🆓的大拇哥吗？👍😚

局部内部类（Local Inner Class）

1. 定义

局部内部类 是定义在方法内部的类，它的作用范围仅限于该方法。局部内部类和方法的局部变量类似，只能在方法中创建和使用，不能在方法外部访问。

2. 作用

封装方法内部的逻辑，局部内部类通常用于仅在方法内使用的辅助类，防止外部访问。
可以访问外部类的所有变量，包括 private 变量，同时也可以访问方法内的局部变量（前提是 final 或 effectively final）。
避免类污染，局部内部类仅在方法内部存在，不会影响整个类的结构。

3. 示例代码

class Outer {
    private String outerMessage = "外部类的变量";

    void outerMethod() {
        // 局部内部类定义在方法内部
        class Inner {
            void display() {
                System.out.println("访问外部类变量：" + outerMessage);
            }
        }

        Inner inner = new Inner(); // 在方法内部创建对象
        inner.display(); // 调用局部内部类的方法
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod(); // 调用外部类方法，间接调用局部内部类
    }
}

输出

访问外部类变量：外部类的变量

解释总结

局部内部类只能在定义它的方法中使用，无法在方法外部访问。
可以访问外部类的 private 变量，和非静态内部类类似。
不能被 static 修饰，因为它属于外部类的实例，而 static 变量属于类本身。

4. 访问方法内的局部变量

局部内部类可以访问方法中的局部变量，但这些局部变量必须是 final 或 effectively final（实际上不会修改的变量）：

class Outer {
    void outerMethod() {
        final String localMessage = "方法内的变量"; // 局部变量必须是 final 或 effectively final

        class Inner {
            void display() {
                System.out.println("访问方法内的变量：" + localMessage);
            }
        }

        Inner inner = new Inner();
        inner.display();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod();
    }
}

输出

访问方法内的变量：方法内的变量

解释

局部内部类可以访问方法内的局部变量，但该变量必须是 final 或不会被修改（effectively final）。
如果 localMessage 不是 final，修改它会导致编译错误。

5. 不能使用 `static` 变量和方法

局部内部类不能定义 static 变量或方法：

class Outer {
    void outerMethod() {
        class Inner {
            static void staticMethod() { // ❌ 错误，局部内部类不能有 static 方法
                System.out.println("静态方法");
            }
        }
    }
}

为什么？

局部内部类是外部类的实例成员，而 static 属于类本身。
静态成员不属于某个特定的对象，而局部内部类属于方法的执行上下文，所以不能使用 static 变量或方法。

6. 适用于方法内部的辅助类

局部内部类适用于方法内部的临时逻辑，如排序、数据转换、任务调度等：

import java.util.Arrays;

class Sorter {
    void sortNumbers(int[] numbers) {
        // 局部内部类：自定义比较器
        class NumberComparator {
            void sort() {
                Arrays.sort(numbers);
                System.out.println("排序后的数组：" + Arrays.toString(numbers));
            }
        }

        NumberComparator comparator = new NumberComparator();
        comparator.sort();
    }
}

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 2};
        new Sorter().sortNumbers(numbers);
    }
}

输出

排序后的数组：[1, 2, 3, 5, 8]

解释

NumberComparator 只用于 sortNumbers() 方法，不需要单独定义为类。
局部内部类可以访问 numbers 变量，因为它是 effectively final（方法内不会修改它）。
适用于封装方法内部的逻辑，避免全局类污染代码结构。

7. 总结

特点	局部内部类
是否需要外部类实例	是
能否访问外部类 `private` 变量	可以
是否能访问方法内变量	只能访问 `final` 或 effectively final 变量
是否能包含 `static` 变量或方法	不能
作用范围	仅在方法内部
适用场景	适用于方法内部的临时逻辑