2

我有一个名为 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 类能够自由地访问其构建器类的私有成员......即使它们是私有的并且在一个单独的顶级类中。

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

4

1 回答 1

3

静态嵌套类，从 JVM 的角度来看，是一个顶级类

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

请注意，它可以双向工作，您的Adjudicator班级也可以访问班级的私人成员Client。

参考：JLS #6.6.1

如果该成员被声明为私有，则当且仅当它出现在包含该成员声明的顶级类的主体内时才允许访问

于 2013-06-04T19:01:34.730 回答