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

更新:

我对此还不清楚。 我试图找到JLS来描述这种行为。 相反,我在JLS的8.3中找到了这个引用:

成员类声明(第8.5节)描述了作为周围类成员的嵌套类。 成员类可能是静态的,在这种情况下,它们无法访问周围类的实例变量; 或者他们可能是内部类(§8.1.3)。

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

结束更新

我正在通过一个静态嵌套类的实例来澄清外部类的私有成员的可访问性。 Java教程指出:

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

从这个问题接受的答案(Java内部类和静态嵌套类)提到:

创建静态内部类的唯一真正可以想象的理由是这样的类可以访问其包含的类的私有静态成员

但是,似乎静态嵌套类也可以访问封闭类的任何实例的私有成员? 这与其他顶级课程在行为上有所不同。 在下面的例子中,静态嵌套类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}

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

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

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

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

这并不意味着静态嵌套类完全无法访问实例变量。 这意味着静态嵌套类无法访问封闭类的实例变量“免费”,这是非静态嵌套类的做法。

对我来说,静态嵌套类和顶级类之间的两个主要差异是

  • 嵌套的静态类和接口表示与它们的封装类/接口更紧密的关联。 例如,为了便于阅读, Map.Entry嵌套接口比MapEntry顶层接口更好。
  • 如果你声明它们是私有的,嵌套类可以作为另一个类的实现细节。 你不能用顶层类来做到这一点,因为它们至少可以保存在同一个包中的类中。
  • 链接地址: http://www.djcxy.com/p/92001.html

    上一篇: Static nested class has full access to private outer class members?

    下一篇: Why can outer Java classes access inner class private members?