java - 为什么可以访问嵌套静态类的成员？

Question

我有一个名为 Adjudicator 的嵌套静态类(不要问......在我阅读有关 Effective Java 中的构建器模式之前，我已经将它命名为有点异想天开)，它是一个构建器，即 Client.Adjudicator 构建客户端对象。

就像 Joshua Bloch 在 Effective Java 中作为示例给出的构建器一样，它通过调用封闭类的构造函数来构建“封闭”类的对象(静态嵌套类并不是真正封闭的)。我的课看起来像这样:

public class Client extends DB {

    private IntegerProperty id =         new SimpleIntegerProperty();
    private LongProperty    defmrnKey =  new SimpleLongProperty();
    private StringProperty  lastName =   new SimpleStringProperty();
    private StringProperty  midName =    new SimpleStringProperty();
    private StringProperty  firstName =  new SimpleStringProperty();
    private IntegerProperty doB =        new SimpleIntegerProperty();
    private StringProperty  gender =     new SimpleStringProperty();

    :
    :

    Client(Client cli) {  // Copy constructor

        this.id.set(cli.getID());
        this.defmrnKey.set(cli.getDefMRNKey());
        this.lastName.set(cli.getLastName());
        this.midName.set(cli.getMidName());
        this.firstName.set(cli.getFirstName());
        this.doB.set(cli.getDoB()); 
        this.gender.set(cli.getGender());
    }

    Client(Client.Adjudicator ad) {  // Invoked by builder

        this.id.set(ad.m_id);
        this.defmrnKey.set(ad.m_defmrnkey);
        this.lastName.set(ad.m_ln);
        this.midName.set(ad.m_mn);
        this.firstName.set(ad.m_fn);
        this.doB.set(ad.m_dob); 
        this.gender.set(ad.m_gen);
    }

    :
    :

    public static class Adjudicator {


        private int     m_id               = DB.KEY_UNDEFINED;
        private long    m_defmrnkey        = DB.KEY_UNDEFINED;
        private String  m_ln               = null;
        private String  m_mn               = null;
        private String  m_fn               = null;
        private int     m_dob              = DB.KEY_UNDEFINED;
        private String  m_gen              = null;

        :
        :

        public Client build() {

            // Invariants all checked here; if ok then...

            return new Client(this);
        }
    }
}

从 JVM 的角度来看，静态嵌套类是一个顶级类，因此它的实例不依赖于任何 Client 实例。

然而，我的 Client 类能够自由地访问其构建器类的私有(private)成员......即使它们是私有(private)的并且在一个单独的顶级类中。

为什么这行得通？这不会破坏封装吗？我很高兴这有效，但这对我来说并不直观。

Answer 1

The static nested class is, from the point of view of the JVM, a top-level class

不完全像你发现的那样。私有(private)成员的范围是顶级封闭类。在您的情况下，它是整个 Client类(class)。

请注意，它同时适用于您的 Adjudicator类可以访问您的 Client 的私有(private)成员也上课。

引用: JLS #6.6.1

if the member is declared private, then access is permitted if and only if it occurs within the body of the top level class that encloses the declaration of the member