编辑“︁Java内部类与封装”︁

= Java内部类与封装 =

== 介绍 ==  
'''Java内部类'''（Inner Class）是指定义在另一个类内部的类。内部类是Java封装特性的重要体现，它允许将逻辑上相关的类组织在一起，增强代码的模块化和可读性。内部类可以访问外部类的私有成员，从而实现更紧密的封装和数据隐藏。  

内部类分为四种类型：  
1. '''成员内部类'''（Member Inner Class）  
2. '''静态内部类'''（Static Nested Class）  
3. '''局部内部类'''（Local Inner Class）  
4. '''匿名内部类'''（Anonymous Inner Class）  

== 成员内部类 ==  
成员内部类是最常见的内部类形式，它直接定义在外部类的成员位置，可以访问外部类的所有成员（包括私有成员）。  

=== 语法示例 ===  
<syntaxhighlight lang="java">  
public class OuterClass {  
    private String outerField = "Outer Field";  

    // 成员内部类  
    class InnerClass {  
        void display() {  
            System.out.println("Accessing outerField from InnerClass: " + outerField);  
        }  
    }  

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

=== 输出 ===  
<pre>  
Accessing outerField from InnerClass: Outer Field  
</pre>  

=== 解释 ===  
* `InnerClass` 是 `OuterClass` 的成员内部类。  
* 内部类可以直接访问外部类的私有字段 `outerField`。  
* 创建内部类实例时，必须先创建外部类实例，再通过 `outer.new InnerClass()` 语法实例化内部类。  

== 静态内部类 ==  
静态内部类使用 `static` 修饰，它不能直接访问外部类的非静态成员，但可以通过外部类实例访问。  

=== 语法示例 ===  
<syntaxhighlight lang="java">  
public class OuterClass {  
    private static String staticField = "Static Field";  
    private String instanceField = "Instance Field";  

    // 静态内部类  
    static class StaticInnerClass {  
        void display() {  
            System.out.println("Accessing staticField: " + staticField);  
            // 编译错误：不能直接访问非静态成员  
            // System.out.println(instanceField);  
        }  
    }  

    public static void main(String[] args) {  
        StaticInnerClass inner = new StaticInnerClass();  
        inner.display();  
    }  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Accessing staticField: Static Field  
</pre>  

== 局部内部类 ==  
局部内部类定义在方法或代码块中，作用域仅限于该方法或块。  

=== 语法示例 ===  
<syntaxhighlight lang="java">  
public class OuterClass {  
    void outerMethod() {  
        final String localVar = "Local Variable";  

        // 局部内部类  
        class LocalInnerClass {  
            void display() {  
                System.out.println("Accessing localVar: " + localVar);  
            }  
        }  

        LocalInnerClass inner = new LocalInnerClass();  
        inner.display();  
    }  

    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        outer.outerMethod();  
    }  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Accessing localVar: Local Variable  
</pre>  

=== 注意事项 ===  
* 局部内部类只能访问方法中的 `final` 或等效不可变变量（Java 8+ 隐式 `final`）。  

== 匿名内部类 ==  
匿名内部类是没有显式类名的局部内部类，通常用于实现接口或继承类。  

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

public class OuterClass {  
    public static void main(String[] args) {  
        // 匿名内部类实现接口  
        Greeting greeting = new Greeting() {  
            @Override  
            public void greet() {  
                System.out.println("Hello from Anonymous Inner Class!");  
            }  
        };  
        greeting.greet();  
    }  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Hello from Anonymous Inner Class!  
</pre>  

== 内部类与封装 ==  
内部类通过以下方式增强封装性：  
1. '''逻辑分组'''：将仅被外部类使用的类隐藏在内部。  
2. '''访问控制'''：内部类可以访问外部类的私有成员，但外部类以外的代码无法直接访问内部类。  
3. '''隐藏实现细节'''：例如，匿名内部类隐藏了接口或抽象类的具体实现。  

=== 实际应用场景 ===  
* '''事件监听器'''（如Swing/AWT中的按钮点击事件）。  
* '''迭代器模式'''（如Java集合框架中的 `Iterator` 实现）。  

=== 类关系图 ===  
<mermaid>  
classDiagram  
    class OuterClass {  
        -outerField: String  
        +main(String[] args)  
    }  
    class InnerClass {  
        +display()  
    }  
    OuterClass --> InnerClass  
</mermaid>  

== 总结 ==  
Java内部类通过嵌套结构强化封装性，提供更灵活的代码组织方式。根据需求选择合适的内部类类型：  
* 需要访问外部实例成员 → '''成员内部类'''  
* 无需访问外部实例成员 → '''静态内部类'''  
* 临时使用 → '''局部内部类''' 或 '''匿名内部类'''  

掌握内部类有助于编写更模块化、可维护的Java代码。

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