day2_604：静态内部类 :-)

可以给我一个🆓的大拇哥吗？👍😚
为什么我喜欢分开写博客，有依据表明信息过载会不利于理解，感兴趣可以看看我的其他博客。

1. 定义

静态内部类（Static Inner Class） 是使用 static 修饰的内部类，它不依赖外部类的实例，可以独立创建。与非静态内部类不同，静态内部类不能访问外部类的实例变量，只能访问外部类的静态变量。

---

2. 作用

• 不依赖外部类实例，可独立创建，不像非静态内部类必须依赖外部类的对象。
• 适用于工具类、构建者模式（Builder Pattern），如 Map.Entry。
• 适用于不需要访问外部类实例变量的场景，减少外部类和内部类之间的耦合，提高代码的可维护性。

---

3. 示例代码

class Outer {
    private static String staticMessage = "Hello, Static Inner Class"; // 外部类的静态变量
    private String instanceMessage = "外部类的实例变量"; // 外部类的实例变量

    // 静态内部类
    static class Inner {
        void display() {
            System.out.println(staticMessage); // 只能访问外部类的静态变量
            // System.out.println(instanceMessage); // 错误，不能访问外部类的实例变量
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner(); // 直接创建静态内部类对象
        inner.display();
    }
}

解释总结

• 静态内部类可以独立创建，不需要 Outer 的对象。
• 只能访问外部类的 static 变量，不能访问实例变量 instanceMessage。
• 静态内部类的对象与外部类的实例无关，减少了外部类的耦合。

---

4. 访问外部类的静态方法

静态内部类不仅可以访问外部类的 static 变量，还可以调用 static 方法：

class Outer {
    private static String message = "Hello, Static Inner Class";

    static class Inner {
        void display() {
            System.out.println(message); // 访问外部类的静态变量
            greet(); // 访问外部类的静态方法
        }
    }

    static void greet() {
        System.out.println("外部类的静态方法");
    }

    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.display();
    }
}

输出

Hello, Static Inner Class
外部类的静态方法

解释

• 静态内部类可以访问外部类的 static 变量和 static 方法。
• 如果 greet() 不是 static，则内部类不能直接调用它。

---

5. 适用于工具类

静态内部类常用于封装工具类（Utility Class），避免工具方法污染外部类：

class MathUtils {
    static class Calculator {
        static int add(int a, int b) {
            return a + b;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.Calculator.add(5, 10);
        System.out.println(result); // 15
    }
}

解释总结

• Calculator 是 MathUtils 的一个工具类，只在 MathUtils 内部使用。
• 可以独立调用 MathUtils.Calculator.add()，而不需要 MathUtils 的对象。

---

6. 适用于构建者模式（Builder Pattern）

静态内部类常用于 Builder 设计模式，用于构造复杂对象：

class Person {
    private String name;
    private int age;

    // 静态内部类 Builder
    static class Builder {
        private String name;
        private int age;

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

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

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

    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    void display() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }

    public static void main(String[] args) {
        Person person = new Person.Builder().setName("张三").setAge(25).build();
        person.display();
    }
}

输出

姓名: 张三, 年龄: 25

解释

• Builder 作为 Person 的静态内部类，不需要 Person 的实例即可使用。
• Builder 模式可以逐步构建 Person 对象，避免多个参数构造方法的问题。

---

7. 总结

特点	静态内部类
是否需要外部类实例	否
能否访问外部类 private 变量	不能
是否能包含 static 方法	可以
创建方式	Outer.Inner inner = new Outer.Inner();
适用场景	适用于工具类、构建者模式

适用于：

• 工具类（如 MathUtils.Calculator），避免静态方法污染外部类。
• 封装细节，减少外部类的依赖，如 Database.ConnectionHelper。
• 构建者模式（Builder Pattern），用于创建复杂对象。

如果内部类不需要访问外部类的实例变量，建议使用静态内部类，它可以减少外部类和内部类的耦合，提高代码的可维护性。

可以关注我，后续持续更新中……