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

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

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

我的2美分：）

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 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

取决于你的语言。您已经将其标记为“面向对象”而不是“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)

我能想到一个原因，为什么你不希望一切都公开。

例如，您从未打算在类外部使用的变量可以被访问，甚至可以通过链变量访问（即object.item.origin.x）直接访问。

通过将所有内容都设为私有，并且仅将您想要扩展的内容以及可能在子类中引用的内容设为受保护的，并且通常只将静态最终对象设为公共，那么您就可以通过使用setter和getter访问您想要的程序内容来控制其他程序员和程序可以在API中使用什么，以及它可以访问什么，以及不能访问什么，或者可能是其他恰好使用您的代码的程序员，可以在您的程序中进行修改。

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

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

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

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