Question

更新

我仍然不清楚这一点。我正试图找到JLS来描述这种行为。相反，我在8.3 of the JLS中找到了这句话：

成员类声明（第8.5节）描述了嵌套类周围班级的成员。成员类可能是静态的，在在哪种情况下，他们无法访问实例变量周围阶级;或者它们可能是内部类（第8.1.3节）。

这是不是意味着嵌套的静态类不应该访问外部类变量？我在哪里可以找到行为应该澄清的内容？

结束更新

我正在寻求通过静态嵌套类的实例来澄清外部类的私有成员的可访问性。 Java tutorials州：

静态嵌套类在行为上是一个顶级类嵌套在另一个顶级类中以方便包装

此问题（Java inner class and static nested class）的接受答案提及：

创建静态内部类的唯一真正可能的原因是这样的类可以访问其包含类的私有静态成员

但似乎静态嵌套类也可以访问封闭类的任何实例的私有成员？这将与任何其他顶级课程有所不同。在下面的示例中，静态嵌套类Builder可以访问Config类的任何实例的私有成员。但是另一个顶级类将无法执行此操作（例如，ConfigTest的实例将无法更改配置对象的私有成员，如注释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
        }

    }

}

ConfigTest：

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}

Answer 1

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

他们无法访问其封闭实例的实例成员（公共成员或私有成员）。但是，如果将静态嵌套类的方法传递给封闭类的实例，则嵌套类将能够访问封闭类的所有成员，而不管其访问级别如何。

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

成员类可能是静态的，在这种情况下，它们无法访问周围类
的实例变量

这并不意味着静态嵌套类根本无法访问实例变量。这意味着静态嵌套类无法访问封闭类的实例变量＆＃34;对于自由＆＃34;，非静态嵌套类的方式。

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

嵌套的静态类和接口表达与它们的封闭类/接口的紧密关联。例如，Map.Entry嵌套接口是比MapEntry顶级接口更好的选择，以提高可读性。
如果您将其声明为私有，嵌套类可以作为另一个类的实现细节。你不能用顶级类做到这一点，因为它们至少可以访问同一个包中的类。

静态嵌套类是否可以完全访问私有外部类成员？

1 个答案: