在同一函数/方法中引发和捕获异常

我编写了一个函数，要求用户输入，直到用户输入正整数（自然数）。有人说我不应该在函数中抛出并捕获异常，而应该让函数的调用者来处理它们。

我不知道其他开发人员对此有何看法。我也可能在函数中滥用异常。这是Java中的代码：

private static int sideInput()
{
    int side = 0;
    String input;
    Scanner scanner = new Scanner(System.in);

    do {
        System.out.print("Side length: ");
        input = scanner.nextLine();
        try {
            side = Integer.parseInt(input);
            if (side <= 0) {
                // probably a misuse of exceptions
                throw new NumberFormatException();
            }
        }
        catch (NumberFormatException numFormExc) {
            System.out.println("Invalid input. Enter a natural number.");
        }
    } while (side <= 0);

    return side;
}

我对两件事感兴趣：

1. 我应该让呼叫者担心异常吗？该功能的要点是它会困扰用户，直到用户输入自然数。函数的重点不好吗？我不是在谈论UI（用户无法在没有正确输入的情况下跳出循环），而是在讨论具有异常处理的循环输入。
2. 您会说throw语句（在这种情况下）是对异常的滥用吗？我可以轻松地创建一个用于检查数字有效性的标志，并根据该标志输出警告消息。但这会在代码中添加更多行，我认为它是完全可读的。

问题是我经常编写一个单独的输入函数。如果用户必须多次输入数字，我将为输入创建一个单独的函数来处理所有格式的例外和限制。

例外的要点是，它允许方法告诉调用者进入了无法正常继续的状态，而不必强迫您在返回值中嵌入错误代码。

在您的情况下，当输入不大于0时，您的方法确切地知道该怎么办。在此处保存行的唯一原因是因为您碰巧抛出的异常与输入不是数字时将得到的异常相同。但是，您抛出的异常不能正确地说明为什么您的代码不喜欢输入。如果其他人来看看这个代码，他们将不得不花费额外的时间来尝试看清楚事情是如何工作的。

这是对异常的错误使用。首先，非正数不是格式异常。

为什么要使用异常？如果您知道不允许输入什么，那就不要中断循环，直到您从用户那里得到有效的输入，如下所示：

while (true)
{
   // Get user input.
   String input = scanner.nextLine();

   try
   {
      side = Integer.parseInt(input);

      break;
   }
   catch (NumberFormatException ex)
   {
      // Inform user of invalid input.
      System.out.println("Invalid input. Enter a natural number.");
   }
}

仅当您打算执行与当前方法调用相关的操作时，才捕获异常；在这种情况下，catch只是向控制台发送一条消息，它与sideInput方法无关，因此可以在调用链/堆栈中进行进一步处理。

可以在这里摆脱try / catch，而只需编写方法调用即可：

//Throws NumberFormatException if read input is less than 0
private static int sideInput()

仍然需要在调用链/堆栈中进一步处理该异常！

您不应该在一个方法中同时抛出和捕获相同的异常，我什至认为catch块将捕获您正在抛出的相同异常，因此您并不是真正在抛出它。

如果parseInt成功，则不是NumberFormatException。

如果side小于零，则应抛出NegativeSideLengthException;。

创建一个名为的自定义/业务异常 NegativeSideLengthException

public class NegativeSideLengthException extends Exception
{


    public NegativeSideLengthException(Integer i)
    {
        super("Invalid negative side length "+i);        
    }

}

然后sideInput抛出NegativeSideLengthException

private static int sideInput() throws NegativeSideLengthException
{
    int side = 0;
    String input;
    Scanner scanner = new Scanner(System.in);

    do {
        System.out.print("Side length: ");
        input = scanner.nextLine();
        try {
            side = Integer.parseInt(input);
            if (side <= 0) {
                throw new NegativeSideLengthException(side);
            }
        }
        catch (NumberFormatException numFormExc) {
            System.out.println("Invalid input. Enter a natural number.");
        }
    } while (side <= 0);

    return side;
}

您甚至可以（如果需要）添加另一个catch块以进行捕获NegativeSideLengthException，而不必让方法将其抛出。

do {
    System.out.print("Side length: ");
    input = scanner.nextLine();
    try {
        side = Integer.parseInt(input);
        if (side <= 0) {
            throw new NegativeSideLengthException(side);
        }
    }
    catch (NumberFormatException numFormExc) {
        System.out.println("Invalid input. Enter a natural number.");
    } catch (NegativeSideLengthException e){
        System.out.println("Invalid input. Enter a non-negative number.");
    }
} while (side <= 0);

标志不是处理异常的好方法。

例外是噩梦般的事情，它们带来的复杂性超出了解决的难度。

首先，如果您没有捕获异常，则调用方只能执行on error resume next该操作，也就是说，一周后，即使您不知道函数可以抛出什么以及如何处理它，也可以：

{
    ...
}
catch(OutOfMemory, CorruptedMemory, BadData, DanglingPointers, UnfinishedCommit)
{
    Console.WriteLine("Nothing to see here, move on.");
    Console.WriteLine("The app is very stable, see, no crashing!");
}

基本上，如果您抓住了它们，则必须对合同和例外保证有很好的了解。在现实世界中很少发生这种情况。而且您的代码也很难阅读。

另外，有趣的是，如果您真的有处理异常的机会，您就需要真正的RAII语言，这很幽默，因为Java和.NET都是关于异常的。

再重复一次，但是...：

http://blogs.msdn.com/b/oldnewthing/archive/2004/04/22/118161.aspx

http://blogs.msdn.com/b/oldnewthing/archive/2005/01/14/352949.aspx

http://www.joelonsoftware.com/items/2003/10/13.html