静态嵌套类（static nested）

1. 静态嵌套类

静态嵌套类（static nested class）是指在另一个类的内部用 修饰符 static 声明的类。本质上它就是一个普通类，只是“住在”另一个类里面，但不与任何外部类对象绑定。

如果说内部类就像总要牵着外部类对象这位“哥哥”的“弟弟”，那么静态嵌套类更像“表亲”——只在家庭聚会出现，其余时间各过各的。

关键区别：

• 没有指向外部类对象的隐式引用——没有 OuterClass.this，也不能访问非静态成员。
• 可以包含静态成员（而普通内部类不行）。
• 创建时不需要外部类对象。

声明语法

声明静态嵌套类很简单：在外部类内部使用关键字 static。

class Outer {
    static class Nested {
        void print() {
            System.out.println("Hello from Nested!");
        }
    }
}

就是这样！没有任何复杂语法——直接写 static class 即可。

可视化：

Outer（外部类）
│
├── Nested（static nested class）
│      └── print()

2. 创建静态嵌套类的实例

最舒服的一点：不需要外部类对象！

Outer.Nested nested = new Outer.Nested();
nested.print(); // Hello from Nested!

注意：我们使用类的全名——Outer.Nested。这就像通过“姓氏”来称呼嵌套类：“Smith.Son”。

与内部类（inner）对比：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 需要 outer 实例

而对于 static nested——完全不需要 Outer 的对象！

3. 对外部类成员的访问

这里是它与内部类最大的不同点。

• 静态嵌套类只能访问外部类的静态成员。
• 不能访问外部类的非静态字段和方法（即使它们是 public）。

示例：

class Outer {
    private static int staticValue = 10;
    private int instanceValue = 20;

    static class Nested {
        void show() {
            System.out.println("Static value: " + staticValue); // OK
            // System.out.println("Instance value: " + instanceValue); // 错误！
        }
    }
}

如果尝试访问非静态字段 instanceValue，编译器会立刻给你“上课”。

为什么？因为 static nested class 并“不知道”应该与哪个 Outer 实例绑定——它没有指向外部类对象的引用。

4. 何时使用静态嵌套类

适用场景？

• 当嵌套类与外部类在逻辑上有关联，但不需要访问外部类对象。
• 当你想封装辅助结构：例如 builder、工具类、枚举，或一个小型不可变对象。
• 当你需要减少包级命名空间的“噪音”：该类只服务于外部类，无需独立对外。

典型场景：

• Builder 模式（尤其是不可变对象）
• 实现辅助结构：例如集合中的内部 Node 类
• 常量或工具的分组

简单选择规则
问自己一个问题：“我的嵌套类是否需要访问某个具体的外部类对象？”
否 → 使用 static class（静态嵌套类）
是 → 使用普通 class（内部类）

5. 使用示例

示例 1：类的 Builder

假设我们有一个 Person 类，希望为它实现 Builder 模式：

public class Person {
    private final String name;
    private final int age;

    // 私有构造函数
    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    // 静态嵌套类 Builder
    public static class Builder {
        private String name;
        private int age;

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

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

    public void printInfo() {
        System.out.println("Person: " + name + ", " + age);
    }
}

使用：

Person person = new Person.Builder()
    .setName("伊万")
    .setAge(30)
    .build();

person.printInfo(); // Person: 伊万, 30

为什么 Builder 是静态嵌套类？
因为它不依赖于某个 Person 对象，它只是帮助创建该对象。它在逻辑上与 Person 相关，但不依赖具体实例。

示例 2：集合中的辅助结构

设想一个“装数字的盒子”，其中用静态嵌套类 Node 来存储元素：

public class IntBox {
    private Node head;

    // 嵌套的 static class
    private static class Node {
        int value;
        Node next;

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

    public void add(int value) {
        Node node = new Node(value);
        node.next = head;
        head = node;
    }

    public void printAll() {
        Node current = head;
        while (current != null) {
            System.out.println(current.value);
            current = current.next;
        }
    }
}

使用：

IntBox box = new IntBox();
box.add(1);
box.add(2);
box.add(3);
box.printAll(); // 3 2 1

为什么 Node 要是 static？
因为每个 Node 都不需要了解整个盒子（IntBox）的存在，它只负责保存数据以及指向下一个 Node 的引用。

示例 3：主类中的工具类

public class MathUtils {
    // 用于复数运算的静态嵌套类
    public static class Complex {
        private final double re;
        private final double im;

        public Complex(double re, double im) {
            this.re = re;
            this.im = im;
        }

        public Complex add(Complex other) {
            return new Complex(this.re + other.re, this.im + other.im);
        }

        @Override
        public String toString() {
            return re + " + " + im + "i";
        }
    }
}

使用：

MathUtils.Complex a = new MathUtils.Complex(1, 2);
MathUtils.Complex b = new MathUtils.Complex(3, 4);
MathUtils.Complex sum = a.add(b);
System.out.println(sum); // 4.0 + 6.0i

6. 实用细节

内部类 vs 静态嵌套类

static

outer.new Inner()

new Outer.Nested()

示意图

flowchart LR
    OuterClass -->|has| InnerClass
    OuterClass -.->|has| StaticNestedClass
    StaticNestedClass -.->|can access| staticMembers
    InnerClass -->|can access| instanceMembers
    InnerClass -->|can access| staticMembers

特性与限制

• Static nested class 可以同时包含普通与静态字段和方法。
• 可以使用任意访问修饰符（public、private、protected、包可见）。
• 可以实现接口并继承其他类。
• 可以是 generic。
• 通常用于封装外部类不对外暴露的内部/工具性类。

泛型静态嵌套类示例：

public class Box {
    public static class Holder<T> {
        private T value;
        public Holder(T value) { this.value = value; }
        public T get() { return value; }
    }
}

何时不应使用 static nested class

• 如果嵌套类需要访问外部类的非静态字段/方法——请使用普通内部类。
• 如果该类需要在外部类之外使用——请将其拆到独立文件。
• 如果该类过大或过于复杂——更适合做成独立类。

7. 常见错误与细节

错误 1：混淆内部类与静态嵌套类。
许多新手会在 static nested class 中访问外部类的非静态成员。但 static nested class 没有指向外部类对象的引用，因此办不到。若你需要访问某个具体对象的状态——请使用普通内部类。

错误 2：试图通过外部类对象来创建静态嵌套类。
没必要写 outer.new Inner()。对于 static nested class，请始终使用 new Outer.Nested()。

错误 3：将需要访问外部类实例状态的逻辑放进 static nested class。
如果类的逻辑与外部类对象的状态紧密相关，static nested class 就不是好选择。请使用普通内部类。

错误 4：嵌套层级过深。
不要滥用嵌套类。如果结构开始变得混乱，最好将一部分类拆到外部。