抽象类中的受保护数据

Question

我的问题具体涉及 Java、抽象类和受保护数据的使用。有人告诉我，所有数据都应该是私有的，并且仅使用受保护的 getter/setter。

现在，我知道我们希望保护数据免遭该类的临时用户的直接操作，并且公共数据成员通常是一种值得怀疑的做法。我看过“Java受保护字段与公共getters”（Java受保护字段与公共getters< /a> ），但我仍然怀疑：

protected int i;  

在抽象类中比：

private int i;  
protected int geti();  
protected void seti(int j); 

当抽象类恰好为子类和受保护范围提供父级/公共设施时，我只是没有看到不利的一面旨在为儿童提供访问权限，同时保护临时用户的数据。我在上面提到的问题中注意到，大多数答案似乎都解决了为什么数据一般应该是私有的而不是公开的问题。我试图将我的问题专门集中在供孩子使用的抽象父级中存在的数据上。迄今为止我听到的唯一合理的评论是，使用父级受保护的数据（例如上面的 int i）会在子类中留下引用未在子类中声明的变量的代码。这个论点不太引人注目（请参阅基类中的公共受保护数据成员？ ）您有一天可能想要更改访问权限，现在您必须尊重您的界面。这是一个抽象类，旨在 100% 的时间进行扩展。

谢谢！对书籍的特定标题/页码引用比对“..任何基本 Java 编程文本...”的引用更有帮助

======================= =================== 2010年10月13日
这是一个关于抽象类的问题，也是一个关于受保护数据的问题。我发现令人失望的是，焦点似乎已经转移到数据隐藏在 OOP 中是否是一件好事的问题上（答案：是）。这里有很多深度涉及抽象类的性质，以及它与常规非最终类的不同之处，以及修复抽象父类中数据项的名称和类型以供使用可能有哪些优势孩子们的班级。我认为这里有可能将创新和更大的控制从抽象父类向下扩展到实现子类。我担心一般原则，例如数据隐藏的优点，可能会成为教条，并抑制创新以及新模式和想法的发展。

感谢所有贡献者。

Answer 1

如果字段是私有的并且通过 getter 和 setter 进行访问，您将能够重新实现 getter 和 setter（例如，删除字段并从外部源更新/读取值），从而更改“字段”的工作方式不触及任何儿童班级。

这是否值得，这取决于你。

Answer 2

将受保护的方法视为子类的接口，就像公共方法是其他所有人的接口一样。

提供访问器使基类能够维持其状态：如果没有故意的技巧，子类不可能破坏它。

Answer 3

访问权限较少不是缺点，而是优点。类应该始终限制对其内部状态的访问尽可能多。不要考虑为什么内部结构应该被隐藏，而是想想为什么它们应该被暴露。在这种情况下，就像在所有情况下一样，除非有充分的理由公开该变量，否则不要公开它。

Answer 4

在 Java 中，除了任何扩展类之外，同一包中的所有成员都可以访问受保护的成员。将字段设置为私有将阻止同一包中的类直接访问它。

还有亚历克斯之前提出的观点。

Answer 5

如果您不需要您的孩子直接访问它，为什么要让他们访问？

使用 protected 并不是一个缺点。但如果没有必要，也许最好避免它并控制对您字段的访问。

Answer 6

如果有人对您的类进行子类化，并将子类放在与您当前类相同的包中，他们可能想要覆盖您的 getter 和 setter。例如，他们想要确保 i 只能设置为大于 1 的值。

除此之外，这实际上取决于您。惯例是，所有东西都有 getter 和 setter。

Answer 7

信息隐藏很有价值，即使在通过继承相关的类中也是如此。

除了允许重新实现之外，如上面 alex 所指出的：

• 您可以在方法中设置断点。
• 您可以在一处添加约束。

Answer 8

您想要使用 getters/setters，因为使用 protected int i; 允许字段覆盖（您希望不惜一切代价避免这种情况）。

您希望禁止字段覆盖，因为它的工作方式与方法覆盖不同。字段覆盖不会使被覆盖的字段不可访问（引用的类型决定您正在使用字段的哪个实例）。

可访问字段应该是最终的或位于最终的类中。

public class OverridingFun {
    public static class Base {
        public int i = 1;
        public int getI(){ return i; }
    }
    public static class A extends Base {
        public int i = 2;
        public int getI(){ return i; }
    }
    public static class B extends A {
        public int i = 3;
        public int getI(){ return i; }
    }
    public static void main(String [] args){
        B b = new B();
        A bAsA = b;
        Base bAsBase = b;

        System.out.println(b.getI());//3
        System.out.println(bAsA.getI());//3
        System.out.println(bAsBase.getI());//3

        System.out.println(b.i);//3
        System.out.println(bAsA.i);//2
        System.out.println(bAsBase.i);//1

        b.i = 4;
        bAsA.i = 5;
        bAsBase.i = 6;

        System.out.println(b.i);//4
        System.out.println(bAsA.i);//5
        System.out.println(bAsBase.i);//6
    }
}

乍一看，这看起来只会使代码难以阅读，但它会对功能产生影响。假设该字段确实被派生类覆盖，因为没有使用设置器，所以无法自动更新基字段，也无法检测是否有人更改了基字段（因为基值仍然可以访问）并且更新派生字段。很容易想象，基本状态和派生状态可能会不同步，并且错误将很难追踪。简而言之，它会导致 API 非常脆弱。

不幸的是，没有办法防止这种情况，因为用于防止覆盖的 final 关键字也会使字段写入一次。所以没有可写的不可重载的字段。

就我个人而言，我对语言设计者允许字段覆盖感到非常惊讶。使用 setter 的优点是每个级别都可以保证其自身状态的完整性，并相信派生类没有弄乱它。字段覆盖只是自找麻烦。