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();
    }
 }

与公共属性不同，全名的实现细节对用户隐藏，用户无法直接访问。

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

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

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

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();
}

太棒了现在我们把瓶子换成这个：

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和其他东西没有奇怪的特定语法，而是到处都有相同的语法。

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

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

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

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

换一种说法：如果你认为你的类的消费者甚至不应该知道你有一个垃圾属性，更不用说随意更改它了，那么给他们一个set_spam方法是你最不想做的事情。

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

但从来没有人做过一般的面向对象设计。他们用特定的语言进行设计和实现。在某些语言中，getter和setter远非一无是处。

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

即使你的语言确实有财产，也可能有不足或不合适的情况。例如，如果要允许子类控制属性的语义，在没有动态访问的语言中，子类不能用计算属性代替属性。

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

此外，遵循所使用语言（或框架）的习惯用法也很重要。如果你用C#编写了漂亮的Ruby风格的代码，那么除了你之外，任何有经验的C#开发人员都会很难读懂它，这很糟糕。有些语言的习俗文化比其他语言更为浓厚-Java和Python在习惯用法方面处于对立的两端，它们恰好拥有两种最强的文化，这可能不是巧合。

除了人类读者之外，还会有图书馆和工具要求你遵守惯例，如果你不遵守惯例，会让你的生活变得更艰难。将Interface Builder小部件挂接到ObjC财产以外的任何东西上，或者在没有getter的情况下使用某些Java模拟库，只会让您的生活更加困难。如果这些工具对你很重要，不要与它们对抗。

原因有很多。我最喜欢的是当你需要改变行为或调整你可以设置的变量时。例如，假设您有一个setSpeed（intspeed）方法。但你希望你只能将最大速度设置为100。您可以执行以下操作：

public void setSpeed(int speed) {
  if ( speed > 100 ) {
    this.speed = 100;
  } else {
    this.speed = speed;
  }
}

现在，如果代码中的每个地方都使用公共字段，然后意识到需要上述要求，该怎么办？寻找公共领域的每一种用法，而不仅仅是修改你的setter。

我的2美分：）

很多人都在谈论二传手和二传手的优点，但我想扮演魔鬼代言人的角色。现在我正在调试一个非常大的程序，程序员们决定让所有的东西都变得更好和更好。这看起来不错，但这是一场逆向工程噩梦。

假设你正在查看数百行代码，你会发现：

person.name = "Joe";

这是一段非常简单的代码，直到你意识到它是一个setter。现在，您遵循该setter，发现它还设置了person.firstName、person.lastName、person.isHuman、person.hasReallyCommonFirstName，并调用person.update（），后者将查询发送到数据库等。哦，这就是发生内存泄漏的地方。

乍一看就理解一段本地代码是具有良好可读性的一个重要特性，getter和setter往往会打破这一特性。这就是为什么我尽量避免使用它们，并在使用它们时尽量减少它们所做的事情。

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

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