Question

在一种方法中进行多次尝试并构造这样的代码是不是很糟糕？

public void whatever() {
   try {
     methodThatMayThrowIOException();
   } catch(IOException io) {
     // do something with exception here
   }

   // do more stuff here that won't throw exceptions

   try {
     methodThatMayThrowCustomException();
   } catch(CustomException ce) {
     // do something with custom exception here
   }
}

Answer 1

如果方法可以继续执行，即使发生指定的异常也没有任何问题，这应该没问题。

如果异常导致问题进一步引起方法中的问题，我会让它冒出来。

Answer 2

不，不是。当它们被抛出时捕获特定异常是一个很好的观点，它肯定比这更好：

public void whatever {
    try {
        methodThatMayThrowIOException();
        // do more stuff here that won't throw exceptions
        methodThatMayThrowCustomException();
    } catch(ParentException e) {
        // do something with custom exception here
    }
}

Answer 3

看起来不错，但这取决于methodThatMayThrowIOException和methodThatMayThrowCustomException做了什么以及第一个（methodThatMayThrowIOException）的失败是否会导致整个whatever方法失败。

Answer 4

这实际上取决于抛出IOException时您打算做什么。你的风格允许你做更多的事情，但是如果你实际上并没有计划利用它，那么使用标准习语可以使这个意图更加清晰。

public void whatever {
   try {
     methodThatMayThrowIOException();
     // do more stuff here that won't throw exceptions
     methodThatMayThrowCustomException();
   } catch(IOException io) {
     // do something with io exception here
   } catch(CustomException ce) {
     // do something with custom exception here
   }
}

在这里你可以快速告诉我，如果抛出IOException，那么你只会在catch块中执行什么操作而不是其他内容。

Answer 5

您的代码读起来就像它一样，因为您想要执行第1部分（并在必要时解析，捕获IOException），执行无异常部分，然后执行methodThatMayThrowCustomException。 您的代码实际上不能以任何其他方式编写并保留相同的功能。这是夸大其词，但任何其他版本在肤浅的意义上都会有所不同。

不相同：

public void whatever {
   try {
     methodThatMayThrowIOException();
     // do more stuff here that won't throw exceptions
     methodThatMayThrowCustomException();
   } catch(IOException io) {
     // do something with io exception here
   } catch(CustomException ce) {
     // do something with custom exception here
   }
}

以及如果抛出任何异常，它将执行的方式是完全不同的。如果你需要从第1部分顺序恢复，在任何情况下点击第2部分，然后继续第3部分，你就无法以任何其他方式编写代码。

有两个catch块没有任何问题，虽然混合导致IOException的东西会抛出一个CustomException，这可能会引起关注点的混合，使你的代码难以理解。但实际上，它不仅仅是有效的，而且是你正在做的事情的唯一方法。

Answer 6

我不明白为什么那会是不好的做法，只要你实际上对你捕获的例外做了一些有用的事情。

Answer 7

AFAICS没有问题。然而，一种方法中的2次尝试抓住了我的眼睛。如果你有同感，我建议你以适当的方式重构它。

Answer 8

没有。这是一个很好的做法，可以缩小范围，抛出某种异常。我在代码中做了很多。

但是，如果你确定在一次尝试... catch块中，某种异常只会被一个独特的函数抛出，把它们放在同一个try块中也行。

Answer 9

这取决于你想要完成的事情。如果代码块应该作为块执行或者根本不执行，如果发生某些异常，通常会在一个try-catch块中包含一个代码块。如果不是这种情况，那么我认为将不同的代码块分别抛入不同的try-catch块并且更好地“在这里做更多不会抛出异常的东西”是更好的选择。只是一个想法！

Answer 10

就个人而言，我觉得它看起来很混乱。我更喜欢只尝试一次，尽可能多的捕获块。我不在乎或在一个方法中使用多个try / catch序列。

这种Java异常风格是不是很糟糕的做法？

10 个答案: