Java内部类与封装[编辑 | 编辑源代码]

介绍[编辑 | 编辑源代码]

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

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

成员内部类[编辑 | 编辑源代码]

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

语法示例[编辑 | 编辑源代码]

  
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();  
    }  
}

输出[编辑 | 编辑源代码]

  
Accessing outerField from InnerClass: Outer Field

解释[编辑 | 编辑源代码]

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

静态内部类[编辑 | 编辑源代码]

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

语法示例[编辑 | 编辑源代码]

  
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();  
    }  
}

输出[编辑 | 编辑源代码]

  
Accessing staticField: Static Field

局部内部类[编辑 | 编辑源代码]

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

语法示例[编辑 | 编辑源代码]

  
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();  
    }  
}

输出[编辑 | 编辑源代码]

  
Accessing localVar: Local Variable

注意事项[编辑 | 编辑源代码]

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

匿名内部类[编辑 | 编辑源代码]

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

语法示例[编辑 | 编辑源代码]

  
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();  
    }  
}

输出[编辑 | 编辑源代码]

  
Hello from Anonymous Inner Class!

内部类与封装[编辑 | 编辑源代码]

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

实际应用场景[编辑 | 编辑源代码]

事件监听器（如Swing/AWT中的按钮点击事件）。
迭代器模式（如Java集合框架中的 `Iterator` 实现）。

类关系图[编辑 | 编辑源代码]

总结[编辑 | 编辑源代码]

Java内部类通过嵌套结构强化封装性，提供更灵活的代码组织方式。根据需求选择合适的内部类类型：

需要访问外部实例成员 → 成员内部类
无需访问外部实例成员 → 静态内部类
临时使用 → 局部内部类 或 匿名内部类

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