编辑“︁Java内部类概述”︁

{{DISPLAYTITLE:Java内部类概述}}

'''Java内部类'''（Inner Class）是定义在另一个类内部的类，它是Java语言中实现封装、代码组织和逻辑分组的重要机制。内部类可以访问外部类的所有成员（包括私有成员），并常用于事件处理、GUI开发以及设计模式实现等场景。

== 基本概念 ==
内部类分为四种类型：
* '''成员内部类'''（Member Inner Class）
* '''静态内部类'''（Static Nested Class）
* '''局部内部类'''（Local Inner Class）
* '''匿名内部类'''（Anonymous Inner Class）

=== 成员内部类 ===
最基础的内部类形式，定义在外部类的成员位置（与字段、方法同级）。

<syntaxhighlight lang="java">
class OuterClass {
    private String outerField = "外部类字段";
    
    class InnerClass {
        void display() {
            System.out.println("访问外部类字段: " + outerField);
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}
</syntaxhighlight>

'''输出结果:'''
<pre>
访问外部类字段: 外部类字段
</pre>

=== 静态内部类 ===
使用<code>static</code>修饰的内部类，不能直接访问外部类的非静态成员。

<syntaxhighlight lang="java">
class OuterClass {
    static String staticField = "静态字段";
    
    static class StaticNestedClass {
        void display() {
            System.out.println("访问静态字段: " + staticField);
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.display();
    }
}
</syntaxhighlight>

=== 局部内部类 ===
定义在方法或作用域内的类，仅在该范围内有效。

<syntaxhighlight lang="java">
class OuterClass {
    void createLocalClass() {
        class LocalClass {
            void display() {
                System.out.println("局部内部类方法");
            }
        }
        new LocalClass().display();
    }
}
</syntaxhighlight>

=== 匿名内部类 ===
没有显式类名的即时实现，常用于接口或抽象类的快速实例化。

<syntaxhighlight lang="java">
interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("匿名内部类实现");
            }
        };
        greeting.greet();
    }
}
</syntaxhighlight>

== 内存关系图解 ==
<mermaid>
classDiagram
    class OuterClass {
        -outerField: String
        +InnerClass inner
    }
    class InnerClass {
        +display()
    }
    OuterClass --> InnerClass : 包含
</mermaid>

== 典型应用场景 ==
* '''事件监听器'''：Swing/AWT中的事件处理
* '''迭代器模式'''：集合类的私有迭代器实现
* '''回调机制'''：通过内部类实现回调接口
* '''线程局部存储'''：ThreadLocal模式中的静态内部类应用

=== 实际案例：GUI事件处理 ===
<syntaxhighlight lang="java">
import javax.swing.*;
import java.awt.event.*;

public class GUIExample {
    public static void main(String[] args) {
        JButton button = new JButton("点击");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("按钮被点击");
            }
        });
    }
}
</syntaxhighlight>

== 内部类与外部类关系 ==
数学上可表示为访问关系：
<math>
\text{InnerClass} \subseteq \text{OuterClass} \implies \text{InnerClass} \times \text{OuterPrivateMembers}
</math>

== 注意事项 ==
* 编译后会生成独立的<code>OuterClass$InnerClass.class</code>文件
* 成员内部类隐式持有外部类引用（可能导致内存泄漏）
* Java 8+允许在局部内部类中访问<code>final</code>或等效<code>final</code>的局部变量

== 最佳实践 ==
* 优先考虑静态内部类（除非需要访问外部实例成员）
* 复杂逻辑建议使用单独类而非多层嵌套
* 匿名内部类适合单方法接口的简单实现

通过掌握内部类的不同形式和适用场景，开发者可以写出更模块化、封装性更好的Java代码。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java内部类]]