是否有任何技术可以使用标志参数拆分方法？

Question

我有一个带有标志参数的方法。我认为将布尔值传递给方法是一种不好的做法（使签名复杂化，违反了“每个方法只做一件事”原则）。我认为将方法分成两种不同的方法更好。但如果我这样做，这两种方法将非常相似（代码重复）。

我想知道是否有一些通用技术可以将带有标志参数的方法拆分为两个单独的方法。

这是我的方法的代码（Java）：

int calculateNumOfLiveOrDeadNeighbors(Cell c, int gen, boolean countLiveOnes) {
   int x = c.getX();
   int y = c.getY();
   CellState state;
   int aliveCounter = 0;
   int deadCounter = 0;
   for (int i = x - 1; i <= x + 1; i++) {
      for (int j = y - 1; j <= y + 1; j++) {
         if (i == x && j == y)
            continue;
         state = getCell(i, j).getCellState(gen);
         if (state == CellState.LIVE || state == CellState.SICK){
            aliveCounter++;
         }
         if(state == CellState.DEAD || state == CellState.DEAD4GOOD){
            deadCounter++;
         }
      }
   }
   if(countLiveOnes){
      return aliveCounter;
   }
   return deadCounter;
}

Answer 1

如果您不喜欢签名上的布尔值，您可以添加两种不带它的不同方法，将主要方法重构为 private：

int calculateNumOfLiveNeighbors(Cell c, int gen) {
  return calculateNumOfLiveOrDeadNeighbors(c, gen, true);
}
int calculateNumOfDeadNeighbors(Cell c, int gen) {
  return calculateNumOfLiveOrDeadNeighbors(c, gen, false);
}

OR

您可以编写一个 结果类或int数组作为输出参数，用于存储两个结果；这将使您摆脱烦人的布尔参数。

Answer 2

我想这取决于每个案例。

在我看来，在这个例子中你有两个选择。

假设您想将调用 calculateNumOfLiveOrDeadNeighbors() 分成

两部分：

calculateNumOfLiveNeighbors() 

并且

calculateNumOfDeadNeighbors()

您可以使用 Template将循环移动到另一个方法的方法。
您可以使用它在两种方法中对死/活细胞进行计数。

private int countCells(Cell c, int gen, Filter filter)
{
    int x = c.getX();
    int y = c.getY();
    CellState state;
    int counter = 0;
    for (int i = x - 1; i <= x + 1; i++) 
    {
        for (int j = y - 1; j <= y + 1; j++) 
        {
            if (i == x && j == y)
                continue;
            state = getCell(i, j).getCellState(gen);
            if (filter.countMeIn(state))
            {
                counter++;
            }
        }
    }
    return counter;
 }

 private interface Filter
 {
      boolean countMeIn(State state);
 }

 public int calculateNumOfDeadNeighbors(Cell c, int gen)
 {
     return countCells(c, gen, new Filter()
                       { 
                           public boolean countMeIn(CellState  state)
                           {
                              return (state == CellState.DEAD || state == CellState.DEAD4GOOD);
                           }
                        });
  }

 public int calculateNumOfLiveNeighbors(Cell c, int gen)
 {
     return countCells(c, gen, new Filter()
                       { 
                           public boolean countMeIn(CellState  state)
                           {
                              return (state == CellState.LIVE || state == CellState.SICK);
                           }
                        });
  }

这很麻烦，甚至可能不值得痛苦。或者，您可以使用 monad 来存储统计计算的结果，并然后在 monad 上使用 getDeadCounter() 或 getLiveCounter() ，正如许多人已经建议的那样。

Answer 3

• 您可以尝试在单个方法中提取通用功能，并且仅使用特定功能
• 您可以使用该标志创建一个私有方法，并从两个公共方法中调用它。因此，您的公共 API 将不会具有“复杂”的方法签名，并且您不会有重复的代码
• 来创建一个返回两个值的方法，并在每个调用者中选择一个（公共方法）。

在上面的例子中，我认为第二个和第三个选项更适用。

Answer 4

似乎最语义清晰的方法是返回一个包含两个值的结果对象，并让调用代码从结果对象中提取它关心的内容。

Answer 5

就像Bozho所说：但是，但是以另一种方式结合第2点和第3点：

创建一个（可能的私有方法），它返回（活着和死了）并且（仅当您在大多数情况下需要分开死或活时）然后添加两个从结果中挑选出死亡或两者的方法：

DeadLiveCounter calcLiveAndDead(..) {}
int calcLive(..) { return calcLiveAndDead(..).getLive; }
int calcDead(..) { return calcLiveAndDead(..).getDead; }

Answer 6

IMO，这种所谓的“每种方法只做一件事”原则需要有选择地应用。你的例子是一个最好不要应用它的例子。相反，我只是稍微简化一下方法实现：

int countNeighbors(Cell c, int gen, boolean countLive) {
   int x = c.getX();
   int y = c.getY();
   int counter = 0;
   for (int i = x - 1; i <= x + 1; i++) {
      for (int j = y - 1; j <= y + 1; j++) {
         if (i == x && j == y)
            continue;
         CellState s = getCell(i, j).getCellState(gen);
         if ((countLive && (s == CellState.LIVE || s == CellState.SICK)) ||
             (!countLive && (s == CellState.DEAD || s == CellState.DEAD4GOOD))) {
            counter++;
         }
      }
   }
   return counter;
}

Answer 7

在使用重构方面，您可以做的一些事情是：

• 复制该方法并创建两个版本，一个具有真正的硬编码，另一个具有假硬编码。您的重构工具应该帮助您内联此常量并根据需要删除代码。
• 重新创建调用正确的 true/false 方法的方法，如上所述，以实现向后兼容性。然后您可以内联此方法。

Answer 8

我倾向于保留 CellState 枚举中的映射进行计数，然后根据需要添加 LIVE 和 SICK 或 DEAD 和 DEAD4GOOD。

int calculateNumOfLiveOrDeadNeighbors(Cell c, int gen, boolean countLiveOnes) {
    final int x = c.getX();
    final int y = c.getY();
    final HashMap<CellState, Integer> counts = new HashMap<CellState, Integer>();
    for (CellState state : CellState.values())
        counts.put(state, 0);

    for (int i = x - 1; i < x + 2; i++) {
        for (int j = y - 1; j < y + 2; j++) {
            if (i == x && j == y)
                continue;
            CellState state = getCell(i, j).getCellState(gen);
            counts.put(state, counts.get(state) + 1);
        }
    }
    if (countLiveOnes)
        return counts.get(CellState.LIVE) + counts.get(CellState.SICK);
    else
        return counts.get(CellState.DEAD) + counts.get(CellState.DEAD4GOOD);
}

Answer 9

有一个私有方法，它是您当前拥有的方法的精确复制和粘贴。
然后创建两个新方法，每个方法都有一个更具描述性的名称，只需使用适当的布尔值调用您的私有方法