使用 getter 还是直接访问私有成员更好？

Question

以下哪个更好？它甚至是基于意见的还是有任何相关的差异？在某些情况下可以选择其中一个吗？

public class MyClass {
    private Integer myField;

    public void setMyField(Integer myField) {
        this.myField = myField;
    }

    public Integer getMyField() {
        return myField;
    }

}

我需要一种方法来检查是否允许某些内容。拜托，我们不要谈论这个代码示例的意义。这只是一个小例子。

实施 1

public boolean isAllowed() {
    MyEnum.ALLOWED.getInt().equals(getMyField());
}

实施 2

public boolean isAllowed() {
    MyEnum.ALLOWED.getInt().equals(myField);
}

编辑： 此帖子在链接的问题中没有答案（请参阅初始帖子的 cmets）

Answer 1

以下哪个更好？它甚至是基于意见还是 有什么相关的区别吗？可以偏爱其中的一个吗 一些场景？

我认为这是一个良好实践的问题。区别在于代码的可读性。

作为一般规则，如果不需要，您应该避免间接使用。 MyClass 的当前实例具有这些字段之一中的信息以实现操作。它不需要对自己隐藏其内部状态。
因此，在内部，MyClass 没有任何有价值的理由支持使用 getMyField() 而不是直接使用 myField 字段。
getMyField() 访问器更适合类的客户端使用。
所以我认为在你的示例代码中无论如何都更好：

public boolean isAllowed() {
    MyEnum.ALLOWED.getInt().equals(myField);
}

编辑：
除了可读性之外，这里还有一个示例为什么您没有兴趣将内部状态耦合到公共 getter。
假设在开发阶段，您从类中删除了 public getMyField() 方法，因为类的客户不再需要或不再需要，如果 isAllowed() 在其实现中依赖于 getMyField()，它将被破坏，您应该替换myField.

Answer 2

我的回答不会提供最丰富的信息，但它将来自处理这种模式的直接经验。在设计对象时，通常倾向于直接访问成员字段而不是依赖访问器。这种愿望源于希望简化对象并避免从简单返回值的方法中添加混乱。以您的示例进一步添加上下文和含义：

public class MyClassmate {
    private Integer age;

    public MyClassmate(Integer age) {
        this.age = age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getAge() {
        return age;
    }

}

这里的年龄是一个简单的数字，似乎没有必要在它周围添加 getter/setter。如果我们添加以下方法，您会很想直接访问该字段，因为行为没有变化：

public Integer calculateScore() {
    if(age > 21) return 100 - getNumberOfIncorrectAnswers();
    //Add 10% before for younger students
    else return (100 - getNumberOfIncorrectAnswers()) + 10;
}

然后，您的对象可能会使用依赖于您继续直接使用它的年龄字段的方法来增加新功能。稍后，您可能会改变年龄的产生方式并从网络中提取价值。您可能不想在构造函数中包含网络逻辑，因为它是一项昂贵的操作，只能在需要时触发。 calculateScore() 方法可以建立网络连接并发现年龄，但所有其他依赖年龄的方法也可以。但是如果 calculateScore 如下所示呢？：

public Integer calculateScore() {
    if(getAge() > 21) return 100 - getNumberOfIncorrectAnswers();
    //Add 10% before for younger students
    else return (100 - getNumberOfIncorrectAnswers()) + 10;
}

然后，您可以在不触及calculateScore() 方法的情况下更改对象获取年龄的方式来增强对象。这意味着您的方法遵循开放封闭原则 (OCP)。它对增强开放但对更改关闭，或者您不必更改方法源即可更改它的年龄。

根据您的应用程序和对象模型的复杂性，有时可能仍然存在封装访问过度的情况，但即使在这些情况下，最好了解直接字段访问的权衡，而且这些更简单的情况大多很少见。

一般而言，您应该了解封装的需求几乎不会立即发生。随着对象的增长，它会随着时间的推移而出现，如果对象从一开始就没有设置封装，那么将其逐步引入会更加昂贵。这就是使这种方法如此难以理解的原因。 感觉为什么需要封装需要经验（即，在几年内多次进行典型的过度简化和痛苦）。这不是你可以用眼睛观察和发现的东西。

也就是说，与现在 IDE 功能不全的时候相比，这曾经是一个更大的问题。今天，您可以在某些 IDE（如 IntelliJ）中使用内置的 encapsulate fields 重构来根据需要引入该模式。即使使用现代 IDE，从一开始就进行封装仍然是有利的。

Answer 3

我建议使用 getter，因为在某些情况下，它可以有一些额外的逻辑（如格式化、检查空值等）。因此，在使用字段本身时，您可能会丢失一些逻辑。

Answer 4

为了保持良好的封装性，首先要考虑的是要在类之外公开哪些方法，例如，如果在这里，例如，您将只使用允许的方法，我只会公开方法，并在构造函数中定义字段，如果该字段适合更改，那么您将需要 getter/setter，但始终取决于您想从类中提供什么。并尽可能多地封装。

public class MyClass {
    private Integer myField;

    MyClass(Integer myField){
        this.myField = myField;
    }

    //Only this method is offered nobody need to know you use myField to say true/false
    public boolean isAllowed() {
        MyEnum.ALLOWED.equals(myField);
    }

}

Answer 5

在我的软件工程课程中，我被告知要实现“秘密原则”。因此，您应该始终使用 getter 和 setter 例程。这样可以确保没有人会意外访问成员变量。

奇怪的函数或对象可能永远看不到甚至改变成员变量，除非你通过 setter 和 getter 明确告诉他们这样做。

Answer 6

由于您的属性是私有的，您只能在其他类中使用 getter 或 setter 方法安全地访问它。所以我会说最好的实现是遵循封装原则的实现，即使用getter而不是直接访问的实现。 这也将防止数据泄露。

https://www.tutorialspoint.com/java/java_encapsulation.htm