Java内部类访问与封装技巧分享

内部类提升Java封装性与模块化，成员内部类可访问外部类所有成员并被private修饰以隐藏细节，如LinkedList中Node类；局部内部类定义在方法内，访问外部final变量，用于特定逻辑块；静态内部类不依赖外部实例，常用于Builder模式；匿名内部类实现接口或继承类，用于事件监听等场景。

Java中的内部类是面向对象编程中一个强大且灵活的特性，它允许将一个类定义在另一个类的内部，从而实现更精细的封装与访问控制。合理使用内部类，不仅能增强代码的模块化，还能有效隐藏实现细节。

成员内部类的封装与访问

成员内部类是定义在外部类内部、且不使用 static 修饰的类。它可以访问外部类的所有成员，包括私有字段和方法，而外部类也可以通过创建内部类实例来间接调用其功能。

为了实现良好的封装，通常将内部类声明为 private，防止外部直接访问，仅通过外部类提供的公共方法暴露必要行为。

假设我们要设计一个链表，但不想暴露节点（Node）结构给外部：

public class LinkedList {
    private Node head;

    // 私有内部类，封装节点结构
    private class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
        }
    }

    // 外部类提供公共方法操作内部类
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
}

这里 Node 类被设为 private，外部无法直接创建或访问，实现了数据结构的封装。

局部内部类与访问控制

局部内部类定义在方法或作用域内，只能在该方法中使用。它适用于只在特定逻辑块中使用的类，进一步缩小作用范围，提升封装性。

局部内部类可以访问外部类的成员，也可以访问所在方法中的 final 或“实际上的 final”变量。

这种机制常用于事件处理、算法实现等场景。

public void process() {
    final int threshold = 10;

    class DataProcessor {
        void filter(int[] values) {
            for (int v : values) {
                if (v > threshold) {  // 可访问外部方法的 final 变量
                    System.out.println(v);
                }
            }
        }
    }

    new DataProcessor().filter(new int[]{5, 12, 8, 15});
}

这个 DataProcessor 类只在 process() 方法中有意义，避免污染类命名空间。

静态内部类简化访问与资源管理

使用 static 修饰的内部类称为静态内部类。它不依赖外部类实例，不能访问外部类的非静态成员，适合用来组织相关工具类或配置类。

静态内部类常用于构建器（Builder）模式中，提高API的可读性和封装性。

public class Computer {
    private String cpu;
    private String ram;

    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
    }

    // 静态内部类作为构建器
    public static class Builder {
        private String cpu;
        private String ram;

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder setRam(String ram) {
            this.ram = ram;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

外部可通过 new Computer.Builder() 构建实例，既保持封装，又提升代码可读性。

匿名内部类的灵活应用

匿名内部类常用于实现接口或继承类的临时扩展，尤其在事件监听、线程任务中广泛使用。

虽然现代Java倾向于使用Lambda表达式替代，但在需要重写多个方法或继承类时仍具价值。

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("运行在内部类线程中");
    }
}).start();

该类没有名字，直接在创建时定义，增强了代码紧凑性。

基本上就这些。内部类的合理使用能显著提升Java程序的封装性和可维护性，关键是根据场景选择合适的类型——成员类用于封装结构，局部类用于限定作用域，静态类用于解耦，匿名类用于轻量扩展。不复杂但容易忽略。