使用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; }
而前者需要的样板代码要少得多。
当前回答
代码不断演变。private非常适合需要数据成员保护的情况。最终，所有的类都应该是一种“小程序”，它有一个定义良好的接口，你不能只使用它的内部结构。
也就是说，软件开发并不是要设置课程的最终版本，就好像你在第一次尝试时按下了一些铸铁雕像一样。当你使用它时，代码更像粘土。它随着你的发展而发展，并进一步了解你正在解决的问题领域。在开发过程中，类之间可能会发生不应有的交互（您计划排除的依赖关系）、合并或拆分。因此，我认为争论归结为人们不想虔诚地写作
int getVar() const { return var ; }
所以你有：
doSomething( obj->getVar() ) ;
而不是
doSomething( obj->var ) ;
getVar（）不仅在视觉上很嘈杂，而且给人一种错觉，认为getingVar（（）在某种程度上是一个比实际更复杂的过程。如果你的类有一个passthrough setter，那么你（作为类编写者）如何看待var的神圣性对你的类的用户来说尤其令人困惑——那么你似乎在设置这些门来“保护”你坚持认为有价值的东西，（var的神圣性）但即使你承认，任何人只要进来并将var设置为他们想要的任何值，而你甚至不去偷看他们在做什么，那么var的保护就没有多大价值。
所以我按如下方式编程（假设采用“敏捷”类型的方法——即当我编写代码时不知道它将要做什么/没有时间或经验来规划一个复杂的瀑布式界面集）：
1） 从具有数据和行为的基本对象的所有公共成员开始。这就是为什么在我所有的C++“示例”代码中，你会注意到我到处使用结构而不是类。
2） 当对象对数据成员的内部行为变得足够复杂时（例如，它喜欢以某种顺序保存内部std:：list），就会编写访问器类型函数。因为我是自己编程的，所以我并不总是立即将成员设置为私有，但是在类的进化过程中，成员将被“提升”为受保护或私有。
3） 完全充实并对其内部有严格规则的类（即，它们确切地知道自己在做什么，你不能“操”（技术术语）它的内部）被赋予类名称，默认为私有成员，只有少数成员被允许公开。
我发现这种方法可以让我避免在一个类进化的早期阶段，当大量数据成员被迁移、转移等时，坐在那里虔诚地编写getter/setter。
其他回答
我们使用getter和setter：
可重用性在编程的后期执行验证
Getter和setter方法是访问私有类成员的公共接口。
封装咒语
封装的口头禅是将字段私有化，将方法公开化。
Getter方法：我们可以访问私有变量。Setter方法：我们可以修改私有字段。
尽管getter和setter方法没有添加新的功能，但我们可以稍后再改变主意，制作该方法
较好的更安全的；和更快。
只要可以使用值，就可以添加返回该值的方法。而不是：
int x = 1000 - 500
use
int x = 1000 - class_name.getValue();
用外行的话来说
假设我们需要存储此人的详细信息。此人具有姓名、年龄和性别字段。要做到这一点，需要创建姓名、年龄和性别的方法。现在，如果我们需要创建另一个人，就需要重新创建姓名、年龄和性别的方法。
我们可以使用getter和setter方法创建一个bean类（Person），而不是这样做。因此，明天我们只要在需要添加新人员时创建这个Bean类（Person类）的对象即可（见图）。因此，我们重用bean类的字段和方法，这要好得多。
如果您想要一个只读变量，但不想让客户端改变访问它的方式，请尝试使用这个模板类：
template<typename MemberOfWhichClass, typename primative>
class ReadOnly {
friend MemberOfWhichClass;
public:
template<typename number> inline bool operator==(const number& y) const { return x == y; }
template<typename number> inline number operator+ (const number& y) const { return x + y; }
template<typename number> inline number operator- (const number& y) const { return x - y; }
template<typename number> inline number operator* (const number& y) const { return x * y; }
template<typename number> inline number operator/ (const number& y) const { return x / y; }
template<typename number> inline number operator<<(const number& y) const { return x << y; }
template<typename number> inline number operator^(const number& y) const { return x^y; }
template<typename number> inline number operator~() const { return ~x; }
template<typename number> inline operator number() const { return x; }
protected:
template<typename number> inline number operator= (const number& y) { return x = y; }
template<typename number> inline number operator+=(const number& y) { return x += y; }
template<typename number> inline number operator-=(const number& y) { return x -= y; }
template<typename number> inline number operator*=(const number& y) { return x *= y; }
template<typename number> inline number operator/=(const number& y) { return x /= y; }
primative x;
};
示例用途：
class Foo {
public:
ReadOnly<Foo, int> cantChangeMe;
};
记住，您还需要添加按位和一元运算符！这只是为了让你开始
代码不断演变。private非常适合需要数据成员保护的情况。最终，所有的类都应该是一种“小程序”，它有一个定义良好的接口，你不能只使用它的内部结构。
也就是说，软件开发并不是要设置课程的最终版本，就好像你在第一次尝试时按下了一些铸铁雕像一样。当你使用它时，代码更像粘土。它随着你的发展而发展，并进一步了解你正在解决的问题领域。在开发过程中，类之间可能会发生不应有的交互（您计划排除的依赖关系）、合并或拆分。因此，我认为争论归结为人们不想虔诚地写作
int getVar() const { return var ; }
所以你有：
doSomething( obj->getVar() ) ;
而不是
doSomething( obj->var ) ;
getVar（）不仅在视觉上很嘈杂，而且给人一种错觉，认为getingVar（（）在某种程度上是一个比实际更复杂的过程。如果你的类有一个passthrough setter，那么你（作为类编写者）如何看待var的神圣性对你的类的用户来说尤其令人困惑——那么你似乎在设置这些门来“保护”你坚持认为有价值的东西，（var的神圣性）但即使你承认，任何人只要进来并将var设置为他们想要的任何值，而你甚至不去偷看他们在做什么，那么var的保护就没有多大价值。
所以我按如下方式编程（假设采用“敏捷”类型的方法——即当我编写代码时不知道它将要做什么/没有时间或经验来规划一个复杂的瀑布式界面集）：
1） 从具有数据和行为的基本对象的所有公共成员开始。这就是为什么在我所有的C++“示例”代码中，你会注意到我到处使用结构而不是类。
2） 当对象对数据成员的内部行为变得足够复杂时（例如，它喜欢以某种顺序保存内部std:：list），就会编写访问器类型函数。因为我是自己编程的，所以我并不总是立即将成员设置为私有，但是在类的进化过程中，成员将被“提升”为受保护或私有。
3） 完全充实并对其内部有严格规则的类（即，它们确切地知道自己在做什么，你不能“操”（技术术语）它的内部）被赋予类名称，默认为私有成员，只有少数成员被允许公开。
我发现这种方法可以让我避免在一个类进化的早期阶段，当大量数据成员被迁移、转移等时，坐在那里虔诚地编写getter/setter。
另一个用途（在支持财产的语言中）是setter和getter可以暗示操作是非平凡的。通常，您希望避免在属性中执行任何计算成本高昂的操作。
根据我的经验，最好将变量设置为私有，并为每个变量提供访问器和修饰符。
通过这种方式，您可以根据需要创建只读变量，也可以只写变量。
下面的实现显示了一个只写变量。
private String foo;
public void setFoo(String foo) { this.foo = foo; }
private String getFoo() { return foo; }
下面显示了一个只读变量。
private String foo;
private void setFoo(String foo) { this.foo = foo; }
public String getFoo() { return foo; }
