静态内部类

「这个类只是逻辑上属于外部类，但它根本不关心外部类的实例。」

静态内部类就是不持有外部类引用的内部类，它属于外部类本身，而非外部类的实例。

基本定义

用 static 修饰的内部类：

public class Outer {
    private static String staticField = "静态字段";
    private String instanceField = "实例字段";

    public static class StaticInner {
        public void display() {
            // ✅ 可以访问外部类的静态成员
            System.out.println(staticField);
            // ❌ 不能访问外部类的实例成员
            // System.out.println(instanceField); // 编译错误
        }
    }
}

创建方式

不需要先创建外部类实例：

public class StaticInnerCreationDemo {

    public static void main(String[] args) {
        // 直接创建，无需外部类实例
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.display();
    }
}

与成员内部类的核心区别

区别	成员内部类	静态内部类
修饰符	无（默认非 static）	static
外部引用	持有外部类引用	不持有外部类引用
创建方式	outer.new Inner()	new Outer.Inner()
访问实例成员	✅ 可以	❌ 不可以

实际应用：复杂数据结构

public class TreeNode {

    private int value;
    private TreeNode left;
    private TreeNode right;

    // 静态内部类：不依赖 TreeNode 实例
    public static class Builder {
        private int value;
        private TreeNode left;
        private TreeNode right;

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

        public Builder left(TreeNode left) {
            this.left = left;
            return this;
        }

        public Builder right(TreeNode right) {
            this.right = right;
            return this;
        }

        public TreeNode build() {
            TreeNode node = new TreeNode();
            node.value = this.value;
            node.left = this.left;
            node.right = this.right;
            return node;
        }
    }

    private TreeNode() {}

    // 使用 Builder
    public static void main(String[] args) {
        TreeNode root = new TreeNode.Builder()
            .value(10)
            .left(new TreeNode.Builder().value(5).build())
            .right(new TreeNode.Builder().value(15).build())
            .build();
    }
}

常见使用场景

1. 工具类归类

public class StringUtils {

    // 静态内部类作为辅助工具
    public static class CharMatcher {
        public static boolean isWhitespace(char c) {
            return c == ' ' || c == '\t' || c == '\n';
        }

        public static boolean isDigit(char c) {
            return c >= '0' && c <= '9';
        }
    }

    public static void main(String[] args) {
        System.out.println(StringUtils.CharMatcher.isDigit('5')); // true
    }
}

2. 配置类

public class DatabaseConfig {

    private String url;

    // 静态内部类封装配置
    public static class Builder {
        private String host = "localhost";
        private int port = 3306;
        private String database;

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

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

        public DatabaseConfig build() {
            DatabaseConfig config = new DatabaseConfig();
            config.url = "jdbc:mysql://" + host + ":" + port + "/" + database;
            return config;
        }
    }

    private DatabaseConfig() {}
}

注意事项

1. 不持有外部引用：静态内部类是独立的，可以直接创建
2. 只能访问静态成员：不能访问外部类的实例字段和方法
3. 属于外部类：通过 OuterClass.InnerClass 访问
4. 生命周期独立：外部类实例被 GC 回收时，静态内部类不受影响
5. 线程安全：静态内部类没有外部类引用，不会导致内存泄漏