java - 什么时候声明是单入口/单出口，什么时候不是？

Question

我不确定我是否能很好地做到这一点，例如，Java 中的 if 语句被称为单入口/单出口语句。如果它的条件为真，这是否被认为是它的单入口点，如果它是假的，它是否被认为是它的单出口点？

if(someCondition)
   doSomething();

以及非-(single-entry/single-exit) 语句的示例是什么？

Answer 1

一种出口点法（单出口）：

public int stringLength(String s) {
  return s.length();
}

两种退出点法：

public int stringLength(String s) {
  if(s == null) {
    return 0;
  }
  return s.length();
}

以下是 Martin Fowler 的书Refactoring中的一段话：

当我与一位被教导在方法中只有一个入口点和一个出口点的程序员一起工作时，我经常发现我使用用保护子句替换嵌套条件。现代语言强制执行一个入口点，而一个出口点实际上不是一个有用的规则。清晰是关键原则：如果方法更清晰，一个出口点，使用一个出口点；否则不要。

以及上述语句的说明，比较这两种方法的代码做同样的事情：

double getPayAmount() { 
    double result; 
    if (_isDead) result = deadAmount(); 
    else {
        if (_isSeparated) result = separatedAmount(); 
        else {
            if (_isRetired) result = retiredAmount(); 
            else result = normalPayAmount();
        };
    } 
    return result; 
};

并有几个退出点：

double getPayAmount() { 
    if (_isDead) return deadAmount(); 
    if (_isSeparated) return separatedAmount(); 
    if (_isRetired) return retiredAmount();    
    return normalPayAmount();
};

嵌套条件代码通常由被教导在方法中有一个退出点的程序员编写。我发现这是一个过于简单的规则。当我对某种方法不再感兴趣时，我会通过退出来表示我缺乏兴趣。指导读者看一个空的 else 块只会妨碍理解。

Answer 2

可能是一个例子：

do {


}while()

或者其他的东西 ：

int someMethod() throws Exception {

  try {
    someInt = someComplexOp();
    return someInt;
   }
   catch(Exception e) {
     log.error(e.getMessage(),e);
     throw e;
   }     
} 

也通过这篇文章。

Answer 3

It's hard to think of multiple entry points with modern high-level languages what with object-orientation and abstraction and encapsulation; but it's easy to see multiple exits from a method. For example:

    public static int CountCommas(string text)
    {
        if (String.IsNullOrEmpty(text))
        {
            return 0;
        }
        if (text.Length == 0)
        {
            return 0;
        }

        int index = 0;
        int result = 0;
        while (index > 0)
        {
            index = text.IndexOf(',', index);
            if (index > 0)
            {
                result++;
            }
        }
        return result;
    }

Answer 4

并非总是我们应该只在某一时刻返回。在检查的上下文中 - 在函数的最顶部尽早返回可能会更干净。但是，如果函数到处都有 return 语句，那可能会导致可读性降低和混乱。

如果您查看上述答案https://stackoverflow.com/a/17295767/5143994（由 Adam Siemion 提供）中提供的 2 个代码示例，我会立即看到嵌套问题。第一个例子（没有多次返回）可以写得更好（见下文）

double getPayAmount() {

    double result;

    if (_isDead) {
        result = deadAmount();
    } else if (_isSeparated) {
        result = separatedAmount();
    } else if (_isRetired) {
        result = retiredAmount();
    } else {
        result = normalPayAmount();
    } 

    return result; 
}

上面的另一个优点是最后，如果您希望为结果添加共同的影响，您可以轻松添加它。例如，考虑您现在想要在最终计算中添加 20% 的额外惩罚。

return result * 1.2; 

但是随着多重回报，增加这种共同影响将变得更加困难。