74. Java 嵌套类 - 局部类 vs. 内部类：有什么相似和不同之处？

74. Java 嵌套类 - 局部类 vs. 内部类：有什么相似和不同之处？

局部类 vs. 内部类：有什么相似和不同之处？

相似点

• 局部类（Local Class）和内部类（Inner Class） 都是 嵌套在外部类内部的类。
• 它们都可以访问外部类的成员变量（包括私有变量）。
• 它们都不能定义 static 成员（除了 final static 常量）。
• 它们都不是 static，所以可以访问外部类的实例成员。

不同点

特性	内部类（成员内部类）	局部类（Local Class）
作用范围	可以在整个外部类中使用	只能在 定义它的方法或代码块 中使用
访问外部类成员	✅ 允许访问 实例变量 和 静态变量	✅ 允许访问 实例变量 和 静态变量
访问局部变量	❌ 不能访问	✅ 只能访问 final 或 effectively final 的变量
允许 static 成员	❌ 不能有静态变量或方法（但可以是 static final 常量）	❌ 不能有静态变量或方法（但可以是 static final 常量）
可以定义接口	✅ 允许	❌ 不允许（因为接口本质上是 static）

---

局部类不能有 static 成员

局部类 本质上是非静态的，因为它可以访问 封装方法的实例变量和局部变量。因此：

• 它不能包含 static 方法、static 变量或 static 代码块。
• 唯一的例外是 final static 常量，因为它们是 编译期常量。

示例 1：局部类不能有 static 方法

public void sayGoodbyeInEnglish() {
    class EnglishGoodbye {
        public static void sayGoodbye() {  // ❌ 报错：局部类不能有 static 方法
            System.out.println("Bye bye");
        }
    }
    EnglishGoodbye.sayGoodbye();
}

❌ 为什么会报错？

因为 EnglishGoodbye 是 局部类，它的生命周期 依赖于它所在的方法，所以 不能定义静态方法。

---

示例 2：局部类可以有 final static 常量

public void sayGoodbyeInEnglish() {
    class EnglishGoodbye {
        public static final String farewell = "Bye bye"; // ✅ 允许，因为是常量
        public void sayGoodbye() {
            System.out.println(farewell);
        }
    }
    EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
    myEnglishGoodbye.sayGoodbye();
}

✅ 为什么 static final 变量可以？

• farewell 是一个 编译时常量（static final 修饰）。
• Java 编译器会在编译时替换 farewell 的值，所以它不会真正成为类的 static 变量。

---

局部类不能定义接口

局部类 不能在方法体内声明接口，因为 接口本质上是 static，而局部类是非静态的。

错误示例

public void greetInEnglish() {
    interface HelloThere {  // ❌ 报错：不能在方法内部声明接口
        public void greet();
    }

    class EnglishHelloThere implements HelloThere {
        public void greet() {
            System.out.println("Hello!");
        }
    }

    HelloThere myGreeting = new EnglishHelloThere();
    myGreeting.greet();
}

❌ 为什么会报错？

• 接口默认是 static 的，但局部类不能是 static。
• 方法体内不允许 static 声明，所以 不能在方法里定义接口。

---

局部类在静态方法中的限制

如果局部类 定义在 static 方法中，那么：

• 它 只能访问封装类的 static 成员。
• 它 不能访问封装类的实例变量。

示例

public class LocalClassExample {
    
    static String regularExpression = "[^0-9]"; // 静态变量

    public static void validatePhoneNumber(String phoneNumber) {
        
        class PhoneNumber {
            String formattedPhoneNumber = null;

            PhoneNumber(String phoneNumber) {
                String currentNumber = phoneNumber.replaceAll(regularExpression, "");  // ✅ 允许
                formattedPhoneNumber = currentNumber;
            }

            public String getNumber() {
                return formattedPhoneNumber;
            }
        }

        PhoneNumber myNumber = new PhoneNumber(phoneNumber);
        System.out.println("Formatted number: " + myNumber.getNumber());
    }
}

✅ 为什么可以访问 regularExpression？

因为 regularExpression 是 static 变量，而 validatePhoneNumber() 也是 static 方法，所以局部类 PhoneNumber 可以访问它。

❌ 但如果 regularExpression 不是 static，会报错

public class LocalClassExample {
    
    String regularExpression = "[^0-9]"; // ❌ 不是静态变量

    public static void validatePhoneNumber(String phoneNumber) {
        
        class PhoneNumber {
            String formattedPhoneNumber = null;

            PhoneNumber(String phoneNumber) {
                String currentNumber = phoneNumber.replaceAll(regularExpression, "");  // ❌ 报错
                formattedPhoneNumber = currentNumber;
            }
        }
    }
}

编译器错误：

无法从静态上下文中引用非静态变量 regularExpression

因为 validatePhoneNumber() 是 static 方法，它 不能访问非静态变量。

---

总结

1️⃣ 局部类 vs. 内部类

• 局部类和内部类都 不能有 static 成员（除了 final static 常量）。
• 局部类 只能在方法内部使用，不像内部类可以在整个外部类中使用。

2️⃣ 局部类的 static 限制

• 不能有 static 方法或 static 变量（除了 final static 常量）。
• 不能在方法内定义 接口（因为接口本质上是 static）。

3️⃣ 局部类在 static 方法中的限制

• 只能访问封装类的 static 成员。
• 不能访问封装类的实例变量（因为 static 方法不能访问实例变量）。

4️⃣ 什么时候用局部类？

✅ 适合用局部类的情况

• 方法内部的 临时逻辑封装。
• 处理 局部数据，而 不需要在外部类中复用。
• 需要访问 方法的 final 变量（或 Java 8+ 的 effectively final 变量）。

❌ 不适合用局部类的情况

• 需要 多个方法都能使用 的工具类（改用 成员内部类）。
• 需要 static 方法或 static 变量（改用 独立的静态类）。
• 需要定义接口（应该在 类级别定义接口）。

希望这次讲解能让你更清楚 局部类的限制和应用场景！🎯 🚀