为什么要使用 getter 和 setter/accessor？

谢谢，这真的澄清了我的想法。现在这是（几乎）10 个（几乎）不使用 getter 和 setter 的好理由：

当您意识到您需要做的不仅仅是设置和获取值时，您可以将字段设为私有，它会立即告诉您直接访问它的位置。您在那里执行的任何验证都只能是上下文无关的，而这种验证在实践中很少见。您可以更改正在设置的值 - 当调用者向您传递一个他们 [震惊恐怖] 希望您按原样存储的值时，这绝对是一场噩梦。您可以隐藏内部表示 - 太棒了，所以您要确保所有这些操作都是对称的，对吧？您已将公共界面与工作表下的更改隔离开来——如果您正在设计一个界面并且不确定直接访问某些内容是否可行，那么您应该继续设计。一些库期望这一点，但不是很多——反射、序列化、模拟对象都可以在公共字段中正常工作。继承此类，您可以覆盖默认功能 - 换句话说，您不仅可以隐藏实现，还可以使其不一致，从而真正混淆调用者。

我要离开的最后三个（N/A 或 D/C）...

---

好吧，我只想补充一点，即使有时它们对于您的变量/对象的封装和安全性是必要的，但如果我们想编写一个真正的面向对象程序，那么我们需要 STOP OVERUSING THE ACCESSORS，因为有时我们在没有必要的时候非常依赖它们，这几乎就像我们将变量公开一样。

---

编辑：我回答这个问题是因为有很多学习编程的人在问这个问题，而且大多数答案在技术上都很有能力，但如果你是新手，它们就不太容易理解。我们都是新手，所以我想我会尝试一个对新手更友好的答案。

两个主要是多态性和验证。即使它只是一个愚蠢的数据结构。

假设我们有这个简单的类：

public class Bottle {
  public int amountOfWaterMl;
  public int capacityMl;
}

一个非常简单的类，它包含多少液体，以及它的容量是多少（以毫升为单位）。

当我这样做时会发生什么：

Bottle bot = new Bottle();
bot.amountOfWaterMl = 1500;
bot.capacityMl = 1000;

好吧，你不会指望它会起作用，对吧？您希望进行某种健全性检查。更糟糕的是，如果我从未指定最大容量怎么办？哦，亲爱的，我们有问题。

但还有另一个问题。如果瓶子只是一种容器呢？如果我们有几个容器，所有容器都装有容量和数量的液体怎么办？如果我们可以创建一个接口，我们可以让程序的其余部分接受该接口，瓶子、塑料桶和各种东西都可以互换使用。那不是更好吗？由于接口需要方法，这也是一件好事。

我们最终会得到类似的东西：

public interface LiquidContainer {
  public int getAmountMl();
  public void setAmountMl(int amountMl);
  public int getCapacityMl();
}

伟大的！现在我们只需将 Bottle 更改为：

public class Bottle extends LiquidContainer {
  private int capacityMl;
  private int amountFilledMl;

  public Bottle(int capacityMl, int amountFilledMl) {
    this.capacityMl = capacityMl;
    this.amountFilledMl = amountFilledMl;
    checkNotOverFlow();
  }

  public int getAmountMl() {
    return amountFilledMl;
  }

  public void setAmountMl(int amountMl) {
     this.amountFilled = amountMl;
     checkNotOverFlow();
  }
  public int getCapacityMl() {
    return capacityMl;
  }

  private void checkNotOverFlow() {
    if(amountOfWaterMl > capacityMl) {
      throw new BottleOverflowException();
    }
}

我将把 BottleOverflowException 的定义作为练习留给读者。

现在请注意这是多么强大。我们现在可以通过接受 LiquidContainer 而不是 Bottle 来处理代码中的任何类型的容器。这些瓶子处理这类东西的方式各不相同。你可以让瓶子在它改变时将它们的状态写入磁盘，或者保存在 SQL 数据库或 GNU 知道的其他东西上的瓶子。

所有这些都可以有不同的方式来处理各种糟糕的事情。瓶子只是检查，如果它溢出它会抛出一个 RuntimeException。但这可能是错误的做法。 （有一个关于错误处理的有用讨论，但我故意在这里保持非常简单。评论中的人可能会指出这种简单方法的缺陷。;)）

是的，似乎我们从一个非常简单的想法转变为快速获得更好的答案。

另请注意，您不能更改瓶子的容量。它现在一成不变。您可以通过将 int 声明为 final 来执行此操作。但如果这是一个列表，您可以清空它，向其中添加新内容，等等。你不能限制接触内脏。

还有第三件事不是每个人都解决过：getter 和 setter 使用方法调用。这意味着它们看起来像其他地方的普通方法。 DTO 和其他东西没有奇怪的特定语法，而是到处都有相同的东西。

---

我知道这有点晚了，但我认为有些人对表演感兴趣。

我做了一点性能测试。我写了一个类“NumberHolder”，它拥有一个整数。您可以使用 getter 方法 anInstance.getNumber() 读取该整数，也可以使用 anInstance.number 直接访问该数字。我的程序通过两种方式读取了 1,000,000,000 次。该过程重复五次并打印时间。我得到以下结果：

Time 1: 953ms, Time 2: 741ms
Time 1: 655ms, Time 2: 743ms
Time 1: 656ms, Time 2: 634ms
Time 1: 637ms, Time 2: 629ms
Time 1: 633ms, Time 2: 625ms

（时间1是直接方式，时间2是getter）

你看，吸气剂（几乎）总是快一点。然后我尝试了不同数量的周期。我没有使用 100 万，而是使用了 1000 万和 10 万。结果：

1000 万次循环：

Time 1: 6382ms, Time 2: 6351ms
Time 1: 6363ms, Time 2: 6351ms
Time 1: 6350ms, Time 2: 6363ms
Time 1: 6353ms, Time 2: 6357ms
Time 1: 6348ms, Time 2: 6354ms

1000 万次循环，时间几乎相同。以下是 10 万（10 万）个周期：

Time 1: 77ms, Time 2: 73ms
Time 1: 94ms, Time 2: 65ms
Time 1: 67ms, Time 2: 63ms
Time 1: 65ms, Time 2: 65ms
Time 1: 66ms, Time 2: 63ms

同样具有不同数量的循环，getter 比常规方式快一点。我希望这对你有所帮助。

---

我们使用 getter 和 setter：

可重用性

在编程的后期执行验证

Getter 和 setter 方法是访问私有类成员的公共接口。

封装咒语

封装的口头禅是使字段私有而方法公开。

Getter 方法：我们可以访问私有变量。 Setter 方法：我们可以修改私有字段。

即使 getter 和 setter 方法没有添加新功能，我们也可以改变主意稍后再制作该方法

更好的;

更安全；和

快点。

在任何可以使用值的地方，都可以添加返回该值的方法。代替：

int x = 1000 - 500

利用

int x = 1000 - class_name.getValue();

通俗地说

https://i.stack.imgur.com/2lgj0.png

假设我们需要存储此 Person 的详细信息。此 Person 具有字段 name、age 和 sex。这样做涉及为 name、age 和 sex 创建方法。现在如果我们需要创建另一个人，就必须重新创建 name、age、sex 的方法。

我们可以创建一个带有 getter 和 setter 方法的 bean class(Person)，而不是这样做。所以明天只要我们需要添加一个新人，我们就可以创建这个 Bean class(Person class) 的对象（见图）。因此我们重用了 bean 类的字段和方法，这要好得多。

---

对于 Java 案例，我花了很长时间思考这个问题，我相信真正的原因是：

接口的代码，而不是实现接口只指定方法，而不是字段

换句话说，在接口中指定字段的唯一方法是提供写入新值的方法和读取当前值的方法。

这些方法是臭名昭著的 getter 和 setter....

---

除非您当前的交付需要，否则不要使用 getter setter 即不要过多考虑未来会发生什么，如果有任何事情要更改，它在大多数生产应用程序、系统中都是一个更改请求。

想简单，容易，需要时增加复杂性。

我不会仅仅因为我认为它是正确的或者我喜欢这种方法而利用对深厚技术知识的企业主的无知。

我编写了没有 getter setter 的大型系统，只有访问修饰符和一些方法来验证 n 执行 biz 逻辑。如果你绝对需要。使用任何东西。

---

它对于延迟加载很有用。假设有问题的对象存储在数据库中，除非你需要它，否则你不想去获取它。如果对象由 getter 检索，则内部对象可以为 null，直到有人请求它，然后您可以在第一次调用 getter 时获取它。

我在一个交给我的项目中有一个基页类，它从几个不同的 Web 服务调用加载一些数据，但这些 Web 服务调用中的数据并不总是在所有子页面中使用。 Web 服务，为了所有的好处，开创了“慢”的新定义，所以如果你不需要，你就不想进行 Web 服务调用。

我从公共字段转移到 getter，现在 getter 检查缓存，如果不存在则调用 Web 服务。因此，只需稍加包装，就可以阻止许多 Web 服务调用。

因此，getter 使我免于尝试在每个子页面上弄清楚我需要什么。如果我需要它，我会调用 getter，如果我还没有它，它会为我找到它。

    protected YourType _yourName = null;
    public YourType YourName{
      get
      {
        if (_yourName == null)
        {
          _yourName = new YourType();
          return _yourName;
        }
      }
    }

---

到目前为止，我在答案中错过了一个方面，即访问规范：

对于成员，您只有一个用于设置和获取的访问规范

对于 setter 和 getter，您可以对其进行微调并分别定义

---

在不支持“属性”（C++、Java）或在将字段更改为属性（C#）时需要重新编译客户端的语言中，使用 get/set 方法更容易修改。例如，向 setFoo 方法添加验证逻辑不需要更改类的公共接口。

在支持“真实”属性的语言（Python、Ruby，也许是 Smalltalk？）中，获取/设置方法没有意义。

---

OO设计的基本原则之一：封装！

它为您提供了许多好处，其中之一是您可以在后台更改 getter/setter 的实现，但只要数据类型保持不变，该值的任何使用者都将继续工作。

---

您应该在以下情况下使用 getter 和 setter：

你正在处理的东西在概念上是一个属性，但是：你的语言没有属性（或一些类似的机制，如 Tcl 的变量跟踪），或者你的语言的属性支持不足以满足这个用例，或者你的语言的（或有时您的框架的）惯用约定鼓励此用例的 getter 或 setter。

您的语言没有属性（或一些类似的机制，如 Tcl 的变量跟踪），或者

您的语言的属性支持不足以满足此用例，或者

您的语言（或有时是您的框架）的惯用约定鼓励此用例的 getter 或 setter。

所以这很少是一个一般的OO问题；这是一个特定于语言的问题，对于不同的语言（和不同的用例）有不同的答案。

从 OO 理论的角度来看，getter 和 setter 是没有用的。你的类的接口是它的作用，而不是它的状态。 （如果没有，你写错了类。）在非常简单的情况下，类的作用只是，例如，表示直角坐标中的一个点，* 属性是接口的一部分； getter 和 setter 只是模糊了这一点。但除了非常简单的情况外，属性、getter 和 setter 都不是接口的一部分。

换句话说：如果您认为您的类的使用者甚至不应该知道您有一个 spam 属性，更不用说能够随意更改它，那么给他们一个 set_spam 方法是您最后要做的事情想要做。

_{* 即使对于那个简单的类，您也不一定希望允许设置 x 和 y 值。如果这真的是一个类，它不应该有 translate、rotate 等方法吗？如果它只是一个类，因为您的语言没有记录/结构/命名元组，那么这实际上不是 OO 的问题……}

但是没有人做过通用的面向对象设计。他们正在使用特定语言进行设计和实施。在某些语言中，getter 和 setter 远非无用。

如果您的语言没有属性，那么表示概念上是属性但实际上是计算或验证等的东西的唯一方法是通过 getter 和 setter。

即使您的语言确实具有属性，也可能存在它们不充分或不合适的情况。例如，如果你想允许子类控制属性的语义，在没有动态访问的语言中，子类不能用计算属性代替属性。

至于“如果我以后想改变我的实现怎么办？”问题（在 OP 的问题和接受的答案中以不同的措辞重复多次）：如果它确实是纯粹的实现更改，并且您从属性开始，则可以将其更改为属性而不影响接口。当然，除非你的语言不支持。所以这真的是同样的情况。

此外，遵循您正在使用的语言（或框架）的习惯用法也很重要。如果你用 C# 编写漂亮的 Ruby 风格的代码，那么除了你之外，任何有经验的 C# 开发人员都将难以阅读它，这很糟糕。一些语言的约定比其他语言具有更强的文化。Java 和 Python 在惯用 getter 方面处于相反的两端，碰巧拥有两种最强大的文化，这可能不是巧合。

除了人类读者之外，还会有一些库和工具希望您遵守约定，如果您不遵守约定，则会使您的生活更加艰难。将 Interface Builder 小部件挂接到除 ObjC 属性之外的任何东西，或者使用某些没有 getter 的 Java 模拟库，只会让您的生活变得更加困难。如果这些工具对您很重要，请不要与它们抗争。

---

从面向对象设计的角度来看，这两种选择都可能通过削弱类的封装而损害代码的维护。如需讨论，您可以查看这篇出色的文章：http://typicalprogrammer.com/?p=23

---

代码进化。 private 非常适合您需要数据成员保护。最终，所有类都应该是一种“小程序”，它们具有定义明确的接口你不能只搞砸的内部结构。

也就是说，软件开发并不是要设置课程的最终版本，就好像您在第一次尝试时要按一些铸铁雕像一样。当您使用它时，代码更像是粘土。它会随着您的开发而发展，并更多地了解您正在解决的问题领域。在开发过程中，类之间的交互可能超出了它们应有的程度（您计划排除依赖关系）、合并在一起或拆分。所以我认为辩论归结为人们不想虔诚地写作

int getVar() const { return var ; }

所以你有了：

doSomething( obj->getVar() ) ;

代替

doSomething( obj->var ) ;

getVar() 不仅在视觉上很嘈杂，而且给人一种错觉，即 gettingVar() 在某种程度上是一个比实际情况更复杂的过程。您（作为课程作者）如何看待 var 的神圣性对于您的课程的用户来说尤其令人困惑，如果它有一个 passthru setter - 那么看起来您设置这些门是为了“保护”您坚持的东西是有价值的，（var 的神圣性）但即使您承认 var 的保护也没有多大价值，因为任何人都可以进入并且 set var 获得他们想要的任何价值，没有你甚至偷看他们在做什么。

所以我编程如下（假设是“敏捷”类型的方法——即当我编写代码时不知道它会做什么/没有时间或经验来计划一个精心设计的瀑布式界面集）：

1) 从具有数据和行为的基本对象的所有公共成员开始。这就是为什么在我的所有 C++“示例”代码中，您会注意到我到处都使用 struct 而不是 class。

2) 当对象的数据成员的内部行为变得足够复杂时，（例如，它喜欢以某种顺序保持内部 std::list），编写访问器类型函数。因为我自己编程，所以我并不总是立即设置成员 private，但在类演变的某个地方，成员将被“提升”为 protected 或 private。

3) 给出了完全充实并对其内部有严格规则的类（即，他们确切地知道他们在做什么，并且你不能用它的内部来“操”（技术术语）） class 名称、默认私有成员和仅允许成为 public 的少数成员。

我发现这种方法可以让我避免在类演化的早期阶段，当大量数据成员被迁移出去、转移等等时，坐在那里虔诚地编写 getter/setter。

---

考虑使用访问器的充分理由是没有属性继承。请参见下一个示例：

public class TestPropertyOverride {
    public static class A {
        public int i = 0;

        public void add() {
            i++;
        }

        public int getI() {
            return i;
        }
    }

    public static class B extends A {
        public int i = 2;

        @Override
        public void add() {
            i = i + 2;
        }

        @Override
        public int getI() {
            return i;
        }
    }

    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.i);
        a.add();
        System.out.println(a.i);
        System.out.println(a.getI());
    }
}

输出：

0
0
4

---

Getter 和 setter 用于实现面向对象编程的两个基本方面，它们是：

抽象封装

假设我们有一个 Employee 类：

package com.highmark.productConfig.types;

public class Employee {

    private String firstName;
    private String middleName;
    private String lastName;

    public String getFirstName() {
      return firstName;
    }
    public void setFirstName(String firstName) {
       this.firstName = firstName;
    }
    public String getMiddleName() {
        return middleName;
    }
    public void setMiddleName(String middleName) {
         this.middleName = middleName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFullName(){
        return this.getFirstName() + this.getMiddleName() +  this.getLastName();
    }
 }

在这里，全名的实现细节对用户是隐藏的，用户不能直接访问，这与公共属性不同。

---

如果您不需要任何验证，甚至不需要维护状态，即一个属性依赖于另一个属性，那么我们需要在一个属性发生更改时维护状态。您可以通过公开字段而不使用 getter 和 setter 来保持简单。

我认为随着程序的发展，OOP 使事情变得复杂，它成为开发人员扩展的噩梦。

一个简单的例子；我们从 xml 生成 c++ 头文件。标头包含不需要任何验证的简单字段。但仍然像在 OOPS 访问器中一样，我们按照以下方式生成它们。

const Filed& getfield() const
Field& getField() 
void setfield(const Field& field){...} 

这非常冗长，不是必需的。一个简单的

struct 
{
   Field field;
};

足够且可读。函数式编程没有数据隐藏的概念，他们甚至不需要它，因为它们不会改变数据。

---

getter 和 setter 方法是访问器方法，这意味着它们通常是用于更改私有类成员的公共接口。您使用 getter 和 setter 方法来定义属性。您可以将 getter 和 setter 方法作为类外部的属性来访问，即使您在类中将它们定义为方法。类之外的那些属性可以具有与类中的属性名称不同的名称。

使用 getter 和 setter 方法有一些优点，例如能够让您创建具有复杂功能的成员，您可以访问类似的属性。它们还允许您创建只读和只写属性。

尽管 getter 和 setter 方法很有用，但您应该注意不要过度使用它们，因为在某些情况下，它们会使代码维护更加困难。此外，它们还提供对您的类实现的访问，例如公共成员。 OOP 实践不鼓励直接访问类中的属性。

当您编写类时，总是鼓励您将尽可能多的实例变量设为私有，并相应地添加 getter 和 setter 方法。这是因为有好几次您可能不想让用户更改您的类中的某些变量。例如，如果您有一个私有静态方法来跟踪为特定类创建的实例数，您不希望用户使用代码修改该计数器。只有构造函数语句应该在调用该变量时递增该变量。在这种情况下，您可能会创建一个私有实例变量，并只允许计数器变量使用 getter 方法，这意味着用户只能使用 getter 方法检索当前值，而无法设置新值使用setter方法。创建不带 setter 的 getter 是使类中的某些变量只读的简单方法。

---

DataStructure 和 Object 是有区别的。

数据结构应该暴露其内在而不是行为。

一个物体不应该暴露它的内在，但它应该暴露它的行为，这也被称为得墨忒耳法则

大多数 DTO 更多地被认为是一种数据结构，而不是对象。他们应该只公开他们的数据而不是行为。在 DataStructure 中使用 Setter/Getter 将暴露行为而不是其中的数据。这进一步增加了违反得墨忒耳法则的机会。

鲍勃叔叔在他的书清洁代码中解释了得墨忒耳定律。

有一个著名的启发式叫做得墨忒耳定律，它说模块不应该知道它所操作的对象的内部结构。正如我们在上一节中看到的，对象隐藏了它们的数据并暴露了操作。这意味着对象不应通过访问器公开其内部结构，因为这样做是公开而不是隐藏其内部结构。更准确地说，得墨忒耳定律说类 C 的方法 f 应该只调用以下方法： C 由 f 创建的对象 作为参数传递给 f 的对象 保存在 C 的实例变量中的对象 该方法应该不要在任何允许的函数返回的对象上调用方法。换句话说，与朋友交谈，而不是与陌生人交谈。

因此，据此，LoD 违规示例是：

final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();

这里，函数应该调用它的直接朋友的方法，这里是ctxt，它不应该调用它的直接朋友的朋友的方法。但这条规则不适用于数据结构。所以在这里，如果 ctxt、option、scratchDir 是数据结构，那么为什么要用一些行为来包装他们的内部数据并违反 LoD。

相反，我们可以做这样的事情。

final String outputDir = ctxt.options.scratchDir.absolutePath;

这满足了我们的需求，甚至不违反 LoD。

灵感来自 Robert C. Martin（鲍勃叔叔）的 Clean Code

---

此外，这是为了“面向未来”您的课程。特别是，从字段更改为属性是 ABI 中断，因此如果您稍后决定需要更多逻辑而不仅仅是“设置/获取字段”，那么您需要中断 ABI，这当然会给任何事情带来问题否则已经针对您的班级进行了编译。

---

另一种用途（在支持属性的语言中）是 setter 和 getter 可以暗示操作是不平凡的。通常，您希望避免在属性中做任何计算上昂贵的事情。

---

getter/setter 的一个相对现代的优势是可以更轻松地在标记（索引）代码编辑器中浏览代码。例如，如果您想查看谁设置了成员，您可以打开 setter 的调用层次结构。

另一方面，如果成员是公共的，则这些工具无法过滤对该成员的读/写访问权限。因此，您必须艰难地使用该成员的所有用途。

---