Design patterns 关于方法及其实例变量的使用，类应该如何在内部结构化？

我在决定如何在内部创建类时一直遇到问题。最初，我将使用一个外部类来处理所有变量管理：

String destination = car.setDestination("San Fransisco");
int totalGas = car.getAmountOfGas();
int requiredGas = car.gasRequiredForDestination(destination);
boolean enough = car.hasEnoughGas(totalGas, destination);
if (enough) 
   car.travelToDestination()

但是我觉得很奇怪，另一个类应该为car类的数据做所有的工作，因为car应该能够自己完成大部分工作。所以为了解决这个问题，我想。。。嗯，让我把这一切都放在课堂上看起来应该去的地方。我认为这样做可以避免在方法之间来回传递太多数据。然后我得到了这个：

Class Car {
  String location = "home";
  String destination;
  int totalGas = 0;
  int requiredGas = 0;
  boolean enoughGas = false;

  public Car (String destination, int totalGas) {
    this.destination = destination;
    this.totalGas = totalGas;
  }
  public boolean travelToDestination() {
     getGasRequiredForDestination();
     hasEnoughGas();
     if (enoughGas == true)
        location = destination;
  }

所以我在这里遇到的问题是，现在是的，我不必传递数据，事情看起来非常干净，但是现在我依赖于每个函数将值返回给实例变量。这本身并不可怕，但我觉得这是非常错误的。与此同时，我对自己说，当我似乎只需要操纵实例变量时，我将所有这些数据从一个地方传递到另一个地方是没有意义的。另一方面，我的程序在一行中有6行：

myMethod {
  doThis()
  doThat()
  checkThis()
  checkTheOtherThing()
}

在现实生活中，我从来没有见过这样做的事情，所以我试图基本上弄清楚A这是否是错误的B如果是，我们什么时候应该将信息粘贴在实例变量中，而不是到处传递。面向对象允许我们这样做，但我不知道这是否是一件好事。这样做或不这样做是否涉及OO原则？也许是我违反了一些我不知道的事情

我已经编写OO很长时间了，但我经常会遇到类似这样的问题，所以我希望能解决它。如果有任何书籍推荐涉及OO更棘手的一面，我也会对此感兴趣

---

编辑：我应该马上说，这是一个虚构的例子，所以在现实世界中，我可能不一定会这样做。但是我需要一些例子，因为我的代码太复杂了。

这个问题可以由比我聪明的人详细解释。但我的看法是：

我倾向于尝试将类定义为一些数据，以及需要按照类继承层次结构对它们执行的一组操作。所以您在Car类上封装操作的方法是正确的，因为在本例中，您只需

Car.travelToDestination()

那就好了

myMethod {
  doThis()
  doThat()
  checkThis()
  checkTheOtherThing()
}

这并没有错，因为上面所有的方法都在执行一个逻辑操作，我强烈建议让这些方法只执行一个逻辑操作，并且正确使用它们

关于传递的类数据，如果您可以在一个类中内部封装数据和操作，通常认为这是一个好的设计，在您的示例中，这似乎就是您想要做的

---

关于这本书的推荐，我发现我自己有一个关于课堂设计的优秀章节，第六章叫做“工作课堂”，我认为这应该可以解决这样的疑问。我发现自己经常提到它。不管怎样，我认为这本书应该是所有程序员的必读之书。

这个问题可以由比我聪明的人详细解释。但我的看法是：

我倾向于尝试将类定义为一些数据，以及需要按照类继承层次结构对它们执行的一组操作。所以您在Car类上封装操作的方法是正确的，因为在本例中，您只需

Car.travelToDestination()

那就好了

myMethod {
  doThis()
  doThat()
  checkThis()
  checkTheOtherThing()
}

这并没有错，因为上面所有的方法都在执行一个逻辑操作，我强烈建议让这些方法只执行一个逻辑操作，并且正确使用它们

关于传递的类数据，如果您可以在一个类中内部封装数据和操作，通常认为这是一个好的设计，在您的示例中，这似乎就是您想要做的

---

关于这本书的推荐，我发现我自己有一个关于课堂设计的优秀章节，第六章叫做“工作课堂”，我认为这应该可以解决这样的疑问。我发现自己经常提到它。不管怎样，我认为这本书应该是所有程序员的必读之作。

我认为你的问题可能在于，应该有一个类去读它。我并不假装理解您所谈论的领域，但与问题相关的一些明显的类似乎是：

汽车 地图 出行计划 地方 航路点 我通常不会问一辆车是否能从一个地方开到另一个地方——我可能会问它在目前的油箱负荷下能走多远。我不希望它知道如何到达旧金山或里程，我从地图上，使用航路点得到了一些信息。所有这些都应该由旅行计划员来协调，他会给出最终的答案

所有这些类都将拥有自己的专业成员数据，并将使用spe进行交互

---

cific成员功能。其中一些函数会将其他类的实例作为参数。

我认为您的问题可能在于，应该有一个类。我并不假装理解您所谈论的领域，但与问题相关的一些明显的类似乎是：

汽车 地图 出行计划 地方 航路点 我通常不会问一辆车是否能从一个地方开到另一个地方——我可能会问它在目前的油箱负荷下能走多远。我不希望它知道如何到达旧金山或里程，我从地图上，使用航路点得到了一些信息。所有这些都应该由旅行计划员来协调，他会给出最终的答案

---

所有这些类都将拥有自己的专业成员数据，并将使用特定的成员函数进行交互。其中一些函数将其他类的实例作为参数。

实际上，您不应该使用实例变量将数据传递给方法。为什么不在一个方法中使用函数结果

public boolean travelToDestination(string destination) {
   int requiredGas = getGasRequiredForDestination(destination);
   boolean enoughGas = hasEnoughGas(requiredGas);
   if (enoughGas) {
      location = destination;
      totalgas -= requiredgas;
   }
}

这使代码的读者能够清楚地了解GetGas是如何用于估计的，并且具有足够的Gas，而不必寻找副作用。这叫做最小惊奇原则

---

在控制流离开类方法之后，应该使用实例变量来存储对象的状态，在这种情况下，控制从travelToDestination返回后的location和totalgas。如果控件应提前返回，例如当汽车通过多个步骤行驶到其目的地时，则需要在字段变量中存储附加信息

实际上，您不应该使用实例变量将数据传递给方法。为什么不在一个方法中使用函数结果

public boolean travelToDestination(string destination) {
   int requiredGas = getGasRequiredForDestination(destination);
   boolean enoughGas = hasEnoughGas(requiredGas);
   if (enoughGas) {
      location = destination;
      totalgas -= requiredgas;
   }
}

这使代码的读者能够清楚地了解GetGas是如何用于估计的，并且具有足够的Gas，而不必寻找副作用。这叫做最小惊奇原则

---

在控制流离开类方法之后，应该使用实例变量来存储对象的状态，在这种情况下，控制从travelToDestination返回后的location和totalgas。如果控件应提前返回，例如当汽车通过多个步骤行驶到其目的地时，则需要在字段变量中存储附加信息

尝试更抽象地进行推理：因为类的一个实例正在建模一个真实世界的实体，这是一件好事，当您可以方便地做到这一点时，实例变量应该是表示该事物状态所需的全部，而不是像临时计算结果这样的人工制品，这与现实世界中的任何状态都不对应

所以，例如，考虑你的类：

Class Car {
  String location = "home";
  String destination;
  int totalGas = 0;
  int requiredGas = 0;
  boolean enoughGas = false;

并根据测试对其进行评论，这个实例变量是否是状态的一部分

根据这个标准，位置和总气体似乎很好-一辆真实世界的汽车确实有一个位置，并且车内有一定量的气体，作为其真实世界状态的一部分。其他人则更加可疑。如果您在行程中的不同地点或行程的一段时间代表汽车，目的地就可以了-在任何给定的时间都会有一个当前地点，以及汽车行驶的目的地。但从你的代码判断，这不是你正在做的：如果汽油充足，目的地会立即变成位置，因此你使用了一个简化的现实模型，其中汽车只被表示为在特定的地方，而不是在它们之间的路线上，顺便说一句，这是非常好的：任何抽象都是不可避免和有用的，现实的简化，如果出于应用程序的目的，您可以抽象出各地之间的旅行状态，请尽一切努力。同样的道理也适用于关于所需气体和足够气体的变量，而不是物体状态的自然部分

因此，为适当的方法生成这些局部变量、参数和返回值，即将旅行方法更改为：

  public void travelToDestination(String destination) {
     int requiredGas = getGasRequiredForDestination(destination);
     bool enoughGas = hasEnoughGas(requiredGas);
     if (enoughGas) {
        totalGas -= requiredGas;
        location = destination;
     }
  }

因此，计算所需的一些值，即作为对象状态一部分的值，是实例变量，其他不属于对象状态的计算中间结果是局部变量、参数和返回值

这种混合方法比原始方法更可靠，也更有前途，可以调用所有getter方法eep或者在另一个极端，所有的东西和它的近亲都是一个实例变量，这仅仅是为了计算的方便，与良好的建模方法完全不同

由于实例变量和局部变量因此在大多数计算中是混合的，许多编程风格要求它们具有可区分的名称一些语言（如Python和Ruby）强制要求它们具有可区分的名称-例如，实例变量location将拼写为@location或self.location-但我所说的语言风格并不强制解决这一问题，但仍然允许您将该实例命名为variabl

---

带尾随下划线的e location，或带m_u前缀的m location，等等。

尝试更抽象地推理：在你的类的一个实例建模真实世界的实体时，这是一件好事，如果你可以方便地做到这一点，实例变量应该是表示该事物状态所需的全部，而不是人工制品，例如临时计算结果，它们与任何真实世界的状态都不对应

所以，例如，考虑你的类：

Class Car {
  String location = "home";
  String destination;
  int totalGas = 0;
  int requiredGas = 0;
  boolean enoughGas = false;

并根据测试对其进行评论，这个实例变量是否是状态的一部分

根据这个标准，位置和总气体似乎很好-一辆真实世界的汽车确实有一个位置，并且车内有一定量的气体，作为其真实世界状态的一部分。其他人则更加可疑。如果您在行程中的不同地点或行程的一段时间代表汽车，目的地就可以了-在任何给定的时间都会有一个当前地点，以及汽车行驶的目的地。但从你的代码判断，这不是你正在做的：如果汽油充足，目的地会立即变成位置，因此你使用了一个简化的现实模型，其中汽车只被表示为在特定的地方，而不是在它们之间的路线上，顺便说一句，这是非常好的：任何抽象都是不可避免和有用的，现实的简化，如果出于应用程序的目的，您可以抽象出各地之间的旅行状态，请尽一切努力。同样的道理也适用于关于所需气体和足够气体的变量，而不是物体状态的自然部分

因此，为适当的方法生成这些局部变量、参数和返回值，即将旅行方法更改为：

  public void travelToDestination(String destination) {
     int requiredGas = getGasRequiredForDestination(destination);
     bool enoughGas = hasEnoughGas(requiredGas);
     if (enoughGas) {
        totalGas -= requiredGas;
        location = destination;
     }
  }

因此，计算所需的一些值，即作为对象状态一部分的值，是实例变量，其他不属于对象状态的计算中间结果是局部变量、参数和返回值

这种混合方法比原始方法更可靠，也更有前途，可以调用所有getter方法eep或者在另一个极端，所有的东西和它的近亲都是一个实例变量，这仅仅是为了计算的方便，与良好的建模方法完全不同

---

由于实例变量和局部变量因此在大多数计算中是混合的，许多编程风格要求它们具有可区分的名称一些语言（如Python和Ruby）强制要求它们具有可区分的名称-例如，实例变量location将拼写为@location或self.location-但我指的是不强制执行此问题的语言的风格，但仍然允许您使用尾随下划线命名该实例变量location，或使用前缀m_u命名该实例变量location等等。

我将拉出一个包含起点和终点的Trip对象，并可以计算距离。我不认为一辆车有责任了解和操作一次旅行的细节。一辆汽车的责任是知道它的里程数和能行驶多远，以及去什么地方

你可以从这里往两个方向走。一种是将执行到汽车上的行程的责任，例如：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

但这让我很烦。它将Car-to-Trip连接起来，并导致对Car的两个高级调用，这两个调用都在一次旅行中运行。这意味着你们可能想让一个旅行社成员在车里给car.setTriptrip打电话……但现在我们知道我们走错了路。这样会导致疯狂。汽车现在不仅和Trip相耦合，而且可以拥有一个和汽车无关的对象。你不会问那辆车的行程是什么？你会问那辆车要去哪里

汽车应该做一些简单的汽车事情。加满汽油。开车到这里。开车去。它不应该知道旅行之类的事情。这意味着我们将责任倒置，把旅行的任务交给旅行本身。可能是这样的：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

在trip.travel的通话中，我们可能会看到：

public void travel()
{
    if (this.car.canTravel(this.distance))
    {
         car.travel(this.destination);
    }
    else
    {
         this.result = "Not enough gas";
    }
}

但我们仍然将Trip与Car耦合在一起，所以我们可能想打开一个隐藏实现的传输接口。对我来说，一次旅行拥有一辆交通工具比一辆汽车拥有一次旅行更有意义。传输接口可能是：

interface Transport
{
    public boolean canTravel(int distanceInMiles);
    public void travel(String destination); // seems like we need more than a String here, but you get the idea
}

现在，汽车将执行类似的操作

class Car implements Transport
{
    // implement canTravel and travel
}

最后，Trip可能会执行以下操作：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

---

或者类似的事情。我通常会尝试让我的对象符合最简单的自然事物。如果他们开始获得的知识似乎并没有自然地转化为一些责任，那么我会寻找我需要定义的缺少的类，并开始尝试倒置责任

我将拉出一个包含起点和终点的Trip对象，并可以计算距离。我不认为一辆车有责任了解和操作一次旅行的细节。一辆汽车有责任知道它的里程和里程 它能走多远，能去多少地方

你可以从这里往两个方向走。一种是将执行到汽车上的行程的责任，例如：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

但这让我很烦。它将Car-to-Trip连接起来，并导致对Car的两个高级调用，这两个调用都在一次旅行中运行。这意味着你们可能想让一个旅行社成员在车里给car.setTriptrip打电话……但现在我们知道我们走错了路。这样会导致疯狂。汽车现在不仅和Trip相耦合，而且可以拥有一个和汽车无关的对象。你不会问那辆车的行程是什么？你会问那辆车要去哪里

汽车应该做一些简单的汽车事情。加满汽油。开车到这里。开车去。它不应该知道旅行之类的事情。这意味着我们将责任倒置，把旅行的任务交给旅行本身。可能是这样的：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

在trip.travel的通话中，我们可能会看到：

public void travel()
{
    if (this.car.canTravel(this.distance))
    {
         car.travel(this.destination);
    }
    else
    {
         this.result = "Not enough gas";
    }
}

但我们仍然将Trip与Car耦合在一起，所以我们可能想打开一个隐藏实现的传输接口。对我来说，一次旅行拥有一辆交通工具比一辆汽车拥有一次旅行更有意义。传输接口可能是：

interface Transport
{
    public boolean canTravel(int distanceInMiles);
    public void travel(String destination); // seems like we need more than a String here, but you get the idea
}

现在，汽车将执行类似的操作

class Car implements Transport
{
    // implement canTravel and travel
}

最后，Trip可能会执行以下操作：

Trip trip = new Trip(origin, destination);
Car car = new Car();
car.fillTank();

if (car.canTakeTrip(trip))
    car.takeTrip(trip);

trip.setCar(car);
trip.travel();
System.out.println(trip.result); // might be "Not enough gas" or "Arrived! Wish you were here!"

class Trip
{
    public void travel(Transport transport)
    {
        if (transport.canTravel(this.distance))
        {
             transport.travel(this.destination);
        }
        else
        {
             this.result = "Not enough gas";
        }

    }
}

Car car = new Car();
car.fillUp();
Trip trip = new Trip(); // maybe set Transport on constructor?
trip.travel(car);

---

或者类似的事情。我通常会尝试让我的对象符合最简单的自然事物。如果他们开始获得的知识似乎并没有自然地转化为一些责任，那么我会寻找我需要定义的缺少的类，并开始尝试倒置责任

我会这样做：

Class Car {
    String location = "home";
    int totalGas = 0;

    public Car (int totalGas) {
        this.totalGas = totalGas;
    }

    public boolean travelToDestination(String destination) {
        int requiredGas = getGasRequiredForDestination(destination);
        if(totalGas >= requiredGas){
            location = destination;
            totalGas -= requiredGas;
            return true;
        } else {
            return false;
        }
    }
}

其思想是尽可能少的状态，我所说的状态是指方法范围之外的变量，例如成员变量、全局变量等。。我不确定这个原则是否有一个特定的名称，但我肯定在阅读时在多个地方遇到过类似的原则。我也可以证明从个人经历中减少状态的好处

---

每个额外的成员变量都会降低可维护性，并增加引入bug的机会。仅当成员变量不能是局部变量时才创建它们。

我会这样做：

Class Car {
    String location = "home";
    int totalGas = 0;

    public Car (int totalGas) {
        this.totalGas = totalGas;
    }

    public boolean travelToDestination(String destination) {
        int requiredGas = getGasRequiredForDestination(destination);
        if(totalGas >= requiredGas){
            location = destination;
            totalGas -= requiredGas;
            return true;
        } else {
            return false;
        }
    }
}

其思想是尽可能少的状态，我所说的状态是指方法范围之外的变量，例如成员变量、全局变量等。。我不确定这个原则是否有一个特定的名称，但我肯定在阅读时在多个地方遇到过类似的原则。我也可以证明从个人经历中减少状态的好处

每个额外的成员变量都会降低可维护性，并增加引入bug的机会。仅当成员变量不能是局部变量时才创建它们。

一个对象应该有三个方面；国家、行为和身份。对象的一个关键度量是它具有高的内部内聚性和低的外部耦合性

让您的方法作用于共享的内部状态绝对没有错

我知道你说过你的例子是为了说明一个观点，但是“汽车”看起来更像是“旅程”或“路线”

一个物体应该有三个方面；国家、行为和身份。对象的一个关键度量是它具有高的内部内聚性和低的外部耦合性

让您的方法作用于共享的内部状态绝对没有错

---

我知道你说过你的例子是为了说明一点而编的，但是“汽车”看起来更像是一个“旅程”或“路线”

我读了第一版的《完整的代码》和《重构》等，但是如果你不真正使用它，知识似乎会很快消失。我一定会看看新版的，虽然我发现自己经常在课堂设计等方面使用它，但我一年或两年都会通读一次。这样做的次数足够多，很多最佳实践，如果你使用它们，就会变得本能。相信自己，并尝试一下。它是有效的：我读了第一版的《代码完成》和《重构》等，但是如果你没有真正使用它，知识很快就会消失。我一定会看看新版的，虽然我发现自己经常在课堂设计等方面使用它，但我一年或两年都会通读一次。这样做的次数足够多，很多最佳实践，如果你使用它们，就会变得本能。相信自己，并尝试一下。它起作用了：汽车只是我想出的一个随机的例子。只是为了说明这一点。我很抱歉，如果由于这个事实，它没有意义。通常我也不会让它做这些功能，但我需要想一些半相关的东西，至少汽车只是我想出的一个随机的例子。只是为了说明这一点。我很抱歉，如果由于这个事实，它没有意义。通常我也不会让它做这些功能，但我需要想一些半相关的东西，至少是的，这是一个很好的答案。我需要再考虑一下，b

---

因为在某些情况下，如果您需要从字符串中提取值，并且需要像java中的StringTokenizer一样一次性提取2，那么您确实需要提取它们，以避免将来某个其他函数意外窃取您想要的值时可能出现的问题。因此，既然不能返回2个值，那么至少应该将其存储在对象中。我想你可以用hashmap。。。不确定。StringTokenizer显然是一个不显式建模真实世界实体的类-很好，你绝对也需要其中的一些-它将有自己的状态概念，这些概念与其计算过程有关，而不是与真实世界中的任何东西有关。这很好——只是不要在同一个类中混合考虑关于状态的两种考虑。是的，这是一个很好的答案。我需要进一步考虑一下，因为在某些情况下，如果需要从字符串中提取值，并且需要像java中的StringTokenizer一样一次性提取2，那么确实需要提取它们，以避免将来其他函数意外地窃取所需值时可能出现的问题。因此，既然不能返回2个值，那么至少应该将其存储在对象中。我想你可以用hashmap。。。不确定。StringTokenizer显然是一个不显式建模真实世界实体的类-很好，你绝对也需要其中的一些-它将有自己的状态概念，这些概念与其计算过程有关，而不是与真实世界中的任何东西有关。这很好——只是不要在同一个类中混合考虑关于状态的两种考虑；身份、状态、行为。它是一个非常糟糕的对象，没有内部内聚；身份、状态、行为。它是一个非常糟糕的对象，没有内部内聚。