编辑“︁Java成员内部类”︁（章节）

= Java成员内部类 =

'''成员内部类'''（Member Inner Class）是Java中定义在另一个类的内部且没有使用<code>static</code>修饰的类。它是外部类的一个成员，可以访问外部类的所有成员（包括私有成员），并且依赖于外部类的实例存在。

== 定义与语法 ==
成员内部类的语法如下：
<syntaxhighlight lang="java">
class OuterClass {
    // 外部类的成员变量和方法
    private int outerField = 10;

    class InnerClass {
        // 内部类的成员变量和方法
        void display() {
            System.out.println("访问外部类的成员：" + outerField);
        }
    }
}
</syntaxhighlight>

成员内部类的特点：
* 必须通过外部类的实例创建。
* 可以访问外部类的所有成员（包括私有成员）。
* 不能定义静态成员（除非是编译时常量）。

== 创建成员内部类的实例 ==
由于成员内部类依赖于外部类的实例，因此必须通过外部类对象来创建内部类实例：
<syntaxhighlight lang="java">
public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display(); // 输出：访问外部类的成员：10
    }
}
</syntaxhighlight>

== 访问外部类成员 ==
成员内部类可以直接访问外部类的成员，包括私有成员：
<syntaxhighlight lang="java">
class OuterClass {
    private String secret = "外部类的私有数据";

    class InnerClass {
        void revealSecret() {
            System.out.println("访问外部类的私有数据：" + secret);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.revealSecret(); // 输出：访问外部类的私有数据：外部类的私有数据
    }
}
</syntaxhighlight>

== 成员内部类的内存模型 ==
成员内部类持有对外部类实例的隐式引用，可以通过<code>OuterClass.this</code>显式访问：
<syntaxhighlight lang="java">
class OuterClass {
    int value = 5;

    class InnerClass {
        void printOuterValue() {
            System.out.println("外部类的value：" + OuterClass.this.value);
        }
    }
}
</syntaxhighlight>

<mermaid>
classDiagram
    class OuterClass {
        -int value
        +InnerClass newInnerClass()
    }
    class InnerClass {
        +void printOuterValue()
    }
    OuterClass --> InnerClass : 包含
    InnerClass ..> OuterClass : 持有引用
</mermaid>

== 实际应用场景 ==
成员内部类常用于以下场景：
1. '''封装实现细节'''：将只与外部类相关的辅助逻辑封装在内部。
2. '''事件处理'''：在GUI编程中（如Swing/AWT），用内部类实现事件监听器。
3. '''迭代器模式'''：实现集合类的迭代器。

=== 案例：实现迭代器 ===
<syntaxhighlight lang="java">
class MyCollection {
    private int[] data = {1, 2, 3, 4, 5};

    class MyIterator {
        private int index = 0;

        boolean hasNext() {
            return index < data.length;
        }

        int next() {
            return data[index++];
        }
    }

    MyIterator getIterator() {
        return new MyIterator();
    }
}

public class Main {
    public static void main(String[] args) {
        MyCollection collection = new MyCollection();
        MyCollection.MyIterator iterator = collection.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
</syntaxhighlight>
输出：
<pre>
1
2
3
4
5
</pre>

== 注意事项 ==
1. 成员内部类不能定义静态成员（Java 16+允许静态成员但有限制）。
2. 外部类实例不存在时，成员内部类也不能存在。
3. 序列化成员内部类时需要特殊处理，因为其包含对外部类的引用。

== 成员内部类 vs 静态嵌套类 ==
{| class="wikitable"
|-
! 特性 !! 成员内部类 !! 静态嵌套类
|-
| 定义方式 || 不使用<code>static</code> || 使用<code>static</code>
|-
| 关联性 || 与外部类实例关联 || 不关联外部类实例
|-
| 访问外部类成员 || 可直接访问 || 只能访问静态成员
|-
| 实例化方式 || <code>outer.new Inner()</code> || <code>new Outer.Inner()</code>
|}

== 数学表示 ==
成员内部类可表示为：
<math>
InnerClass \subseteq OuterClass \times \mathcal{P}(Members_{outer})
</math>
其中：
* <math>InnerClass</math>是内部类
* <math>OuterClass</math>是外部类
* <math>\mathcal{P}(Members_{outer})</math>是外部类成员的幂集

== 总结 ==
成员内部类是Java中实现强关联对象的重要机制，它：
* 提供更好的封装性
* 可以直接访问外部类成员
* 适合实现紧密耦合的组件
* 在集合框架和事件处理中广泛应用

理解成员内部类的工作原理有助于编写更优雅、更模块化的Java代码。

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