使用getter和setter（只获取和设置）而不是简单地为这些变量使用公共字段有什么好处？
如果getter和setter所做的不仅仅是简单的get/set，我可以很快地解决这个问题，但我不是100%清楚如何做到：
public String foo;
比：
private String foo;
public void setFoo(String foo) { this.foo = foo; }
public String getFoo() { return foo; }
而前者需要的样板代码要少得多。
当前回答
getter/setter的一个相对现代的优点是，它使在标记（索引）代码编辑器中浏览代码变得更容易。例如，如果您想查看谁设置了成员，可以打开setter的调用层次结构。
另一方面，如果成员是公共的，则这些工具无法过滤对该成员的读/写访问。因此，您必须费力地使用该成员。
其他回答
我知道现在有点晚了，但我想有些人对表演感兴趣。
我做了一个性能测试。我写了一个类“NumberHolder”，它包含一个整数。您可以使用getter方法读取该IntegeranInstance.getNumber（）或通过使用anInstance.number直接访问数字。我的程序通过两种方式读取数字1000000000次。该过程重复五次，并打印时间。我得到了以下结果：
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是吸气方式）
你看，吸气器（几乎）总是快一点。然后我尝试了不同次数的循环。我用了1000万和10万，而不是100万。结果：
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比常规方法快一点。我希望这对你有所帮助。
取决于你的语言。您已经将其标记为“面向对象”而不是“Java”，因此我想指出ChssPly76的答案依赖于语言。例如，在Python中，没有理由使用getter和setter。如果需要更改行为，可以使用一个属性，该属性将getter和setter包装在基本属性访问周围。类似于：
class Simple(object):
def _get_value(self):
return self._value -1
def _set_value(self, new_value):
self._value = new_value + 1
def _del_value(self):
self.old_values.append(self._value)
del self._value
value = property(_get_value, _set_value, _del_value)
在面向对象的语言中，方法及其访问修饰符声明该对象的接口。在构造函数、访问器和赋值器方法之间，开发人员可以控制对对象内部状态的访问。如果变量被简单地声明为公共的，那么就没有办法规范这种访问。当我们使用setter时，我们可以限制用户所需的输入。这意味着这个变量的输入将通过一个适当的通道，通道是我们预先定义的。所以使用setter更安全。
公共字段并不比getter/setter对差，它除了返回字段并赋值之外什么都不做。任何差异都必须存在于其他因素，如可维护性或可读性。
getter/setter对的一个经常提到的优点不是。有一种说法是，您可以更改实现，而不必重新编译客户端。据推测，setter允许您稍后添加验证之类的功能，而您的客户甚至不需要知道它。然而，将验证添加到setter是对其前提条件的更改，违反了以前的合同，这很简单，“您可以将任何东西放在这里，稍后您可以从getter那里获得相同的东西”。
因此，现在您违反了合同，更改代码库中的每个文件是您应该做的事情，而不是避免。如果你避免这样做，你就假设所有的代码都假设这些方法的契约是不同的。
如果这不应该是约定，那么接口允许客户端将对象置于无效状态。这与封装正好相反。如果该字段从一开始就不能真正设置为任何值，为什么验证从一开始不存在？
同样的论点也适用于这些传递getter/setter对的其他假定优点：如果您稍后决定更改设置的值，那么您就违反了合同。如果您在派生类中重写默认功能，而不是进行一些无害的修改（如日志记录或其他不可观察的行为），那么您就违反了基类的约定。这违反了Liskov替代原则，这被视为OO的原则之一。
如果一个类对每个字段都有这些愚蠢的getter和setter，那么它就是一个没有不变量、没有契约的类。这真的是面向对象的设计吗？如果类只有那些getter和setter，那么它只是一个哑数据持有者，哑数据持有者应该看起来像哑数据持有者：
class Foo {
public:
int DaysLeft;
int ContestantNumber;
};
向此类类添加传递getter/setter对不会增加值。其他类应该提供有意义的操作，而不仅仅是字段已经提供的操作。这就是如何定义和维护有用的不变量。
客户：“我可以用这个类的对象做什么？”设计器：“你可以读写几个变量。”客户：“哦……我想很酷吧？”
使用getter和setter是有原因的，但如果这些原因不存在，那么以虚假封装之神的名义制作getter/setter对并不是一件好事。使用getter或setter的有效原因包括经常提到的稍后可以进行的潜在更改，如验证或不同的内部表示。或者，该值应该是客户端可读但不可写的（例如，读取字典的大小），因此简单的getter是一个不错的选择。但是，当你做出选择时，这些理由应该存在，而不仅仅是你以后可能想要的潜在原因。这是YAGNI（你不需要它）的一个例子。
我想发布一个我刚刚完成的真实世界示例：
背景-我使用休眠工具为我的数据库生成映射，这是一个我在开发时正在更改的数据库。我更改数据库模式，推送更改，然后运行hibernate工具来生成java代码。在我想向这些映射实体添加方法之前，一切都很好。如果我修改了生成的文件，则每次对数据库进行更改时都会覆盖这些文件。所以我这样扩展生成的类：
package com.foo.entities.custom
class User extends com.foo.entities.User{
public Integer getSomething(){
return super.getSomething();
}
public void setSomething(Integer something){
something+=1;
super.setSomething(something);
}
}
我上面所做的是用我的新功能（something+1）覆盖超类上的现有方法，而不需要接触基类。如果你在一年前写了一个类，并且想在不改变基类的情况下升级到第2版（测试噩梦），也是同样的情况。希望这会有所帮助。
