嵌入式 if 语句的替代方案？

Question

我有编程经验，但在软件开发方面并不多。我目前正在为我工​​作的公司编写一个软件，我开始挑战自己代码的可读性。

我想知道这是否是嵌入 if 语句的“有效”替代方案，或者是否有更好的方法可以使用。

假设我有以下方法：

public void someMethod()
{
    if (some condition)
    {
        if (some condition 2)
        {
            if (some condition 3)
            {
                // ...etc all the way until:
                doSomething();
            }
            else
            {
                System.err.println("Specific Condition 3 Error");
            }
        }
        else
        {
            System.err.println("Specific Condition 2 Error");
        }
    }
    else
    {
        System.err.println("Specific Condition 1 Error");
    }
}

现在我要指出的第一件事是，在这种情况下，组合条件（与 &&）是不可能的，因为每个条件都有一个我想要报告的唯一错误，如果我将它们组合起来，我不会不能这样做（或者我会吗？）。在有人尖叫“SWITCH STATEMENT！”之前，我应该指出的第二件事。在我看来，并非所有这些条件都可以通过 switch 语句处理；有些是对象特定的方法调用，有些是整数比较等。

也就是说，以下是使上述代码更具可读性的有效方法，还是有更好的方法？

public void someMethod()
{
    if (!some condition)
    {
        System.err.println("Specific Condition 1 Error");
        return;
    }

    if (!some condition 2)
    {
        System.err.println("Specific Condition 2 Error");
        return;
    }

    if (!some condition 3)
    {
        System.err.println("Specific Condition 3 Error");
        return;
    }

    doSomething();
}

因此，基本上，我们不是在 else 块中检查条件并报告错误，而是检查条件的反转，如果为真则返回。结果应该是一样的，但是有没有更好的处理方法？

Answer 1

如果我特别迂腐，我会使用这样的东西。

boolean c1, c2, c3;

public void someMethod() {
  boolean ok = true;
  String err = "";

  if (ok && !(ok &= c1)) {
    err = "Specific Condition 1 Error";
  }

  if (ok && !(ok &= c2)) {
    err = "Specific Condition 2 Error";
  }

  if (ok && !(ok &= c3)) {
    err = "Specific Condition 3 Error";
  }

  if ( ok ) {
    doSomething();
  } else {
    System.out.print(err);
  }
}

你现在是单出口和平房。

已添加

如果 &= 对您来说很困难，请使用以下内容：

  if (ok && !c3) {
    err = "Specific Condition 3 Error";
    ok = false;
  }

Answer 2

我会这样写

if (failing condition) {
    System.err.println("Specific Condition 1 Error");
} else {
    somethingExpensiveCondition2and3Dependon();
    if (failing condition 2)
        System.err.println("Specific Condition 2 Error");
    else if (failing condition 3)
        System.err.println("Specific Condition 3 Error");
    else
        doSomething();
}

Answer 3

是的，在这两种情况下，您的代码都带有条件复杂性的味道 (code smells)

Java 是一种 OOP 语言，因此您的代码应该按照 OOD 的精神进行考虑，如下所示：

for (Condition cond : conditions) {
    if (cond.happens(params))
         cond.getHandler().handle(params);
}

条件列表应该被注入到这个类中，这样当一个新的条件被添加或删除时，这个类不会改变。 (open close principle)

Answer 4

您的第二种方法相当不错。如果你想要一些更巴洛克的东西，你可以将你的条件移动到 Callable 对象中。每个对象还可以提供一种处理错误的方法。这使您可以在不牺牲功能的情况下编写任意长的测试系列。

class Test {
    private final Callable<Boolean> test;
    private final Runnable errorHandler;

    public Test(Callable<Boolean> test, Runnable handler) {
        this.test = test;
        errorHandler = handler;
    }

    public boolean runTest() {
        if (test.call()) {
            return true;
        }
        errorHandler.run();
        return false;
    }
}

然后您可以按如下方式组织您的代码：

ArrayList<Test> tests;

public void someMethod() {
    for (Test test : tests) {
        if (!test.runTest()) {
            return;
        }
    }
    doSomething();
}

编辑

这是上述内容的更通用版本。它应该可以处理几乎所有这种类型的情况。

public class Condition {
    private final Callable<Boolean> test;
    private final Runnable passHandler;
    private final Runnable failHandler;

    public Condition(Callable<Boolean> test,
            Runnable passHandler, Runnable failHandler)
    {
        this.test = test;
        this.passHandler = passHandler;
        this.failHandler = failHandler;
    }

    public boolean check() {
        if (test.call()) {
            if (passHandler != null) {
                passHandler.run();
            }
            return true;
        }
        if (errorHandler != null) {
            errorHandler.run();
        }
        return false;
    }
}

public class ConditionalAction {
    private final ArrayList<Condition> conditions;
    private final Runnable action;

    public ConditionalAction(ArrayList<Condition> conditions,
            Runnable action)
    {
        this.conditions = conditions;
        this.action = action;
    }

    public boolean attemptAction() {
    for (Condition condition : conditions) {
        if (!condition.check()) {
            return false;
        }
    }
    action.run();
    return true;
    }
}

人们可能会想添加某种通用数据，这些数据可以被传递以共享信息或收集结果。与其这样做，我建议在实现条件和操作的对象中实现此类数据共享，并保持此结构不变。

Answer 5

对于这种情况，这与您将获得的一样干净，因为您对每个条件都有自定义标准和自定义响应。

Answer 6

您实际上所做的是在调用doSomething() 方法之前验证一些条件。我会将验证提取到一个单独的方法中。

public void someMethod() {
  if (isValid()) {
    doSomething();
  }
}

private boolean isValid() {
  if (!condition1) {
    System.err.println("Specific Condition 1 Error");
    return false;
  }
  if (!condition2) {
    System.err.println("Specific Condition 2 Error");
    return false;
  }
  if (!condition3) {
    System.err.println("Specific Condition 3 Error");
    return false;
  }
  return true;
}

Answer 7

不，这就是你在 Java 中得到的东西。如果你有太多这些，这可能表明你应该重构一下，甚至可能重新考虑你的算法——尝试简化一下可能是值得的，因为否则你将回到几个月后，想知道为什么a + b + c + d = e 而a + b' + c + d = zebra

Answer 8

您拥有的第二个选项更具可读性。虽然通常不建议多次返回，但将它们全部放在代码的开头是清楚的（并不是它们散布在整个方法中）。另一方面，嵌套的 if 很难理解和理解。