编辑“︁Java嵌套内部类”︁

{{DISPLAYTITLE:Java嵌套内部类}}

'''Java嵌套内部类'''（Nested Inner Class）是定义在另一个类内部的类，能够访问外部类的所有成员（包括私有成员）。这种设计常用于逻辑分组、封装实现细节或实现特定接口。本章将详细讲解其语法、特性及实际应用。

== 基本概念 ==
嵌套内部类分为以下两种主要类型：
* '''非静态嵌套类'''（即'''内部类'''）：持有外部类的引用
* '''静态嵌套类'''：不持有外部类引用

本文重点讨论非静态嵌套类（普通内部类）。

=== 核心特性 ===
* 可直接访问外部类的所有字段和方法（包括<code>private</code>）
* 需要外部类实例才能创建内部类对象
* 编译后会生成独立class文件（格式：<code>OuterClass$InnerClass.class</code>）

== 语法结构 ==
基本定义格式：
<syntaxhighlight lang="java">
class OuterClass {
    // 外部类成员
    private int outerField = 10;
    
    class InnerClass {
        // 内部类成员
        void display() {
            System.out.println("访问外部类字段: " + outerField);
        }
    }
}
</syntaxhighlight>

== 代码示例 ==
=== 基础示例 ===
<syntaxhighlight lang="java">
public class Robot {
    private String model = "X-1000";
    
    // 内部类
    class Arm {
        void lift() {
            System.out.println(model + "的机械臂抬起重物");
        }
    }

    public static void main(String[] args) {
        Robot robot = new Robot();
        Robot.Arm arm = robot.new Arm(); // 创建内部类实例
        arm.lift();
    }
}
</syntaxhighlight>

'''输出结果：'''
<pre>
X-1000的机械臂抬起重物
</pre>

=== 访问机制 ===
内部类隐式持有外部类引用，可通过<code>OuterClass.this</code>显式访问：
<syntaxhighlight lang="java">
class Outer {
    int x = 10;
    
    class Inner {
        void print() {
            System.out.println("外部类x: " + Outer.this.x);
        }
    }
}
</syntaxhighlight>

== 内存关系图解 ==
<mermaid>
classDiagram
    class OuterClass {
        -privateField
        +method()
    }
    class InnerClass {
        +innerMethod()
    }
    OuterClass --> InnerClass : 持有实例
    InnerClass --> OuterClass : 隐式引用
</mermaid>

== 实际应用场景 ==
=== 1. 事件处理 ===
GUI开发中常用内部类实现事件监听：
<syntaxhighlight lang="java">
// Swing示例
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击");
    }
});
</syntaxhighlight>

=== 2. 迭代器实现 ===
集合类常用内部类实现迭代器：
<syntaxhighlight lang="java">
public class MyCollection {
    private String[] items = {"A", "B", "C"};
    
    public Iterator<String> iterator() {
        return new MyIterator();
    }
    
    // 内部类实现迭代器
    private class MyIterator implements Iterator<String> {
        private int index = 0;
        
        public boolean hasNext() {
            return index < items.length;
        }
        
        public String next() {
            return items[index++];
        }
    }
}
</syntaxhighlight>

== 进阶特性 ==
=== 访问权限控制 ===
内部类可声明为<code>private</code>/<code>protected</code>实现更精细的封装：
<syntaxhighlight lang="java">
class SecureContainer {
    private class SecretImplementation {
        // 仅限外部类访问的实现
    }
}
</syntaxhighlight>

=== 局部内部类 ===
在方法内定义的内部类（可访问方法final参数）：
<syntaxhighlight lang="java">
class Processor {
    void process(final int param) {
        class LocalInner {
            void display() {
                System.out.println("参数值: " + param);
            }
        }
        new LocalInner().display();
    }
}
</syntaxhighlight>

== 注意事项 ==
* 每个内部类实例都关联一个外部类实例
* 序列化内部类时需要特殊处理（外部类字段不会自动序列化）
* 在静态上下文中无法直接访问非静态内部类

== 数学表示 ==
内部类与外部类的关系可表示为：
<math>
I_c = f(O_i) \quad \text{其中} \quad O_i \in \text{OuterClass实例}
</math>

== 性能考量 ==
* 创建内部类比普通类稍慢（需要维护外部类引用）
* 在性能敏感场景应谨慎使用
* 每增加一个内部类会增加一个.class文件

通过系统学习嵌套内部类，开发者可以更好地组织代码结构，实现更优雅的设计模式。建议结合具体项目实践来巩固理解。

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