Java 内部类完全指南：成员内部类、静态内部类、局部内部类、匿名内部类

在 Java 中，内部类（Inner Class）是指定义在另一个类内部的类。内部类主要用于封装逻辑、简化代码，并且可以访问外部类的成员变量和方法。本文将带你从零开始全面掌握 Java 内部类的类型、作用及应用场景。

---

1. 什么是内部类？

**内部类（Inner Class）**是定义在另一个类内部的类，它依赖于外部类的存在。Java 主要提供以下几种内部类：

1. 成员内部类（Member Inner Class）
2. 静态内部类（Static Inner Class）
3. 局部内部类（Local Inner Class）
4. 匿名内部类（Anonymous Inner Class）

作用：

• 封装性：内部类可以访问外部类的私有成员，增强封装性。
• 逻辑性：内部类逻辑上依赖于外部类，便于管理代码。
• 简化代码：特别是在事件监听和回调机制中，匿名内部类可以减少代码量。

---

2. 成员内部类（Member Inner Class）

成员内部类是定义在外部类成员位置的非静态类。它可以访问外部类的所有成员（包括私有成员）。

2.1 代码示例

class Outer {
    private String message = "Hello from Outer";

    // 成员内部类
    class Inner {
        void display() {
            System.out.println(message); // 访问外部类的私有成员
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建外部类实例
        Outer outer = new Outer();
        // 通过外部类实例创建内部类实例
        Outer.Inner inner = outer.new Inner();
        inner.display(); // 输出：Hello from Outer
    }
}

2.2 关键点

• 需要先创建外部类对象，才能创建内部类对象：
  Outer.Inner inner = outer.new Inner();
• 内部类可以访问外部类的私有成员。

---

3. 静态内部类（Static Inner Class）

静态内部类使用 static 修饰，它不能访问外部类的非静态成员，但可以访问静态成员。

3.1 代码示例

class Outer {
    private static String staticMessage = "Hello from Static Inner Class";

    // 静态内部类
    static class StaticInner {
        void display() {
            System.out.println(staticMessage); // 只能访问外部类的静态成员
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 直接创建静态内部类的实例，不需要外部类对象
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.display(); // 输出：Hello from Static Inner Class
    }
}

3.2 关键点

• 无需创建外部类对象，可以直接创建静态内部类对象：

  Outer.StaticInner inner = new Outer.StaticInner();
  

• 只能访问外部类的静态成员，不能访问非静态成员。

---

4. 局部内部类（Local Inner Class）

局部内部类是定义在方法内部的类，它的作用域仅限于该方法，类似于局部变量。

4.1 代码示例

class Outer {
    void show() {
        // 局部内部类
        class LocalInner {
            void display() {
                System.out.println("Hello from Local Inner Class");
            }
        }
        // 创建局部内部类对象
        LocalInner inner = new LocalInner();
        inner.display();
    }
}

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

4.2 关键点

• 只能在定义它的方法内部使用，无法在外部创建对象。
• 不能使用 static 修饰，因为它依赖于外部方法的实例。

---

5. 匿名内部类（Anonymous Inner Class）

匿名内部类是没有名字的类，通常用于简化代码，特别适用于接口或抽象类的实现。

5.1 代码示例

abstract class Animal {
    abstract void makeSound();
}

public class Main {
    public static void main(String[] args) {
        // 创建匿名内部类
        Animal dog = new Animal() {
            @Override
            void makeSound() {
                System.out.println("Woof! Woof!");
            }
        };

        dog.makeSound(); // 输出：Woof! Woof!
    }
}

5.2 关键点

• 适用于 接口和抽象类的实现，无需创建单独的子类。
• 只能使用一次，无法复用。

---

6. 内部类使用场景

✅ 成员内部类

• 适用于一个类需要访问另一个类的私有成员。
• 例如 GUI 编程中的监听器。

✅ 静态内部类

• 适用于工具类（Utility Class），如 Map.Entry。
• 适用于外部类和内部类逻辑关系较弱的情况。

✅ 局部内部类

• 适用于封装仅在方法内使用的逻辑，如计算器的临时逻辑。

✅ 匿名内部类

• 适用于简化代码，如 Runnable、Comparator 实现。

---

7. 内部类最佳实践

类型	访问外部类	是否可 static	适用场景
成员内部类	✅ 可以	❌ 不可以	需要访问外部类成员
静态内部类	❌ 不能访问非静态	✅ 可以	工具类、减少外部类耦合
局部内部类	✅ 可以	❌ 不可以	方法内部的封装
匿名内部类	✅ 可以	❌ 不可以	一次性使用的类

---

8. 总结

1. 成员内部类：外部类的非静态类，可以访问外部类的所有成员。
2. 静态内部类：使用 static 修饰，不能访问外部类的非静态成员。
3. 局部内部类：定义在方法内部，作用域仅限方法内。
4. 匿名内部类：适用于简化代码，通常用于接口或抽象类的实现。