更新:

这个我还是不太清楚。我试图找到 JLS 来描述这种行为。相反，我在 8.3 of the JLS 中找到了这句话:

Member class declarations (§8.5) describe nested classes that are members of the surrounding class. Member classes may be static, in which case they have no access to the instance variables of the surrounding class; or they may be inner classes (§8.1.3).

这是否意味着嵌套静态类不应该访问外部类变量？我在哪里可以找到关于行为应该是什么的说明？

结束更新

我正在寻求通过静态嵌套类的实例对外部类的私有(private)成员的可访问性进行一些澄清。 Java tutorials状态:

a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience

这个问题 ( Java inner class and static nested class ) 的公认答案提到:

The only real conceivable reason to create a static inner class is that such a class has access to its containing class's private static members

但似乎静态嵌套类也可以访问封闭类的任何实例的私有(private)成员？这在行为上与任何其他顶级类不同。在下面的示例中，静态嵌套类 Builder 可以访问 Config 类的任何实例的私有(private)成员。但是另一个顶级类将无法做到这一点(例如 ConfigTest 的实例将无法更改配置对象的私有(private)成员，如注释的 manipulateConfig 方法。

我的理解正确吗？我没有在 JLS 中找到引用来为我澄清这一点。

配置:

public class Config {

    private String param1;
    private int param2;

    private Config() {}

    public String getParam1() { return param1; }
    public int getParam2() { return param2; }

    @Override
    public String toString() {
        return "Config{" + "param1=" + param1 + ", param2=" + param2 + '}';
    }



    public static class Builder {

        private String param1;
        private int param2;

        public Builder setParam1(String param1) { this.param1 = param1; return this; }
        public Builder setParam2(int param2) { this.param2 = param2; return this; }

        public Config build() {
            Config config = new Config();
            config.param1 = param1;  // <- Accessing private member of outer class
            config.param2 = param2;
            return config;
        }


        public void modifyParm2(Config config, int newVal) {
            config.param2 = newVal;  // <- Able to modify private member of any enclosing class
        }

    }

}

配置测试:

public class ConfigTest {


    private Config getConfig() {

        Config.Builder builder = new Config.Builder();

        Config config = builder
                .setParam1("Val1")
                .setParam2(2)
                .build();

        return config;

    }

//    private void manipulateConfig(Config config, String newParam1) {
//        config.param1 = newParam1;
//    }

    public static void main(String[] args) {

        ConfigTest configTest = new ConfigTest();
        Config config = configTest.getConfig();
        System.out.println(config);

        Config.Builder anotherBuilder = new Config.Builder();
        anotherBuilder.modifyParm2(config, 3);
        System.out.println(config);

//        configTest.manipulateConfig(config, "val11");

    }

}

运行 ConfigTest 的输出:

Config{param1=Val1, param2=2}
Config{param1=Val1, param2=3}

最佳答案

您链接到的答案并不完全正确:嵌套静态类可以访问其封闭类的所有成员，包括私有(private)成员。

他们无法访问其封闭实例的实例成员，无论是公共(public)的还是私有(private)的。但是，如果您将静态嵌套类的方法传递给封闭类的实例，则嵌套类将能够访问封闭类的所有成员，无论他们的访问级别如何。

我认为静态/非静态混淆来自 JLS 的这一行:

Member classes may be static, in which case they have no access to the instance variables of the surrounding class

这并不意味着静态嵌套类根本无法访问实例变量。这意味着静态嵌套类无法像非静态嵌套类那样“免费”访问封闭类的实例变量。

对我来说，静态嵌套类和顶级类之间的两个主要区别是

1. 嵌套的静态类和接口(interface)表达了与其封闭类/接口(interface)更紧密的关联。例如，Map.Entry 嵌套接口(interface)是比 MapEntry 顶级接口(interface)更好的可读性选择。
2. 嵌套类可以作为另一个类的实现细节，如果你声明它们是私有(private)的。您不能对顶级类执行此操作，因为它们至少对同一包中的类仍然可以访问。

关于java - 静态嵌套类可以完全访问私有(private)外部类成员吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27181290/