在Java中有没有办法抛出多个异常?
public void dosomething() throws IOException, AWTException {
// ....
}
这表示该方法可能会抛出这两个异常中的一个(以及任何未经检查的异常)。您不能同时抛出两个异常,这在Java或其他任何语言中都不太有意义。
您还可以抛出一个嵌套的异常,其中包含另一个异常对象。但这几乎不能算作“抛出两个异常”,它只是表示由两个异常对象(通常来自不同层)描述的单个异常情况。
你不能抛出两个异常。也就是说,你不能这样做:
try {
throw new IllegalArgumentException(), new NullPointerException();
} catch (IllegalArgumentException iae) {
// ...
} catch (NullPointerException npe) {
// ...
}
您可以使用cause-constructor嵌套异常来执行以下操作:
try {
Exception ex1 = new NullPointerException();
// Throw an IllegalArgumentException that "wraps" ex1
throw new IllegalArgumentException(ex1);
} catch (IllegalArgumentException iae) {
// handle illegal argument...
throw iae.getCause(); // throws the cause (the NullPointerException)
}
这篇文章介绍了关于链式异常的好方法:Programming.Guide: Chained Exceptions
一个异常可以抑制另一个异常。
try {
Exception ex1 = new NullPointerException();
// Throw an IllegalArgumentException that "suppresses" ex1
IllegalArgumentException ex2 = new IllegalArgumentException();
ex2.addSuppressed(ex1);
throw ex2;
} catch (IllegalArgumentException iae) {
// handle illegal argument...
... iae.getSuppressed() ... // get hold of the suppressed exceptions
}
这是一篇关于抑制异常的好文章:Programming.Guide: Suppressed Exceptions
我想你可以创建一个包含已捕获异常列表的异常,并抛出该异常,例如:
class AggregateException extends Exception {
List<Exception> basket;
}
public class AggregateException extends Exception {
public void addException(Exception ex){
addSuppressed(ex);
exception = true;
}
}
public class AnyClass{
public AggregateException aggExcep = new AggregateException();
public void whereExceptionOccurs(){
try{
//some code
}catch(Exception e){
aggExcep.addException(e);
//throw aggExcep;
}
}
}
在 catch 块中,可以使用相同的引用 aggExcep 调用 addException 方法来抑制任何异常。在需要显式抛出 aggExcep 的地方,可以使用 'throw' 关键字。
Throwable 类中预定义了
方法,它将指定的异常附加到被抑制的异常列表中,以便传递此异常。void addSuppressed(Throwable exception)
抛出多个异常是没有意义的,因为你不可能有多个错误(错误可能有多个原因,但在任何时候只能有一个错误)。
如果你需要跟踪原因,可以链接异常:
} catch (Exception ex) {
throw new RuntimeException("Exc while trying ...", ex);
}
getCause()
获得。Exception
。此外,为了重新包装异常,我会使用一个项目特定的异常基类。这样我就可以区分可接受的异常、我已经包装并计划处理的异常,以及意外的异常。 - unholysampler"发生了 " + errors.size() + " 个错误:\n" + errors.stream().map(String::valueOf).collect(joining("\n")
。 - Aaron Digulla我见过一种模式,即自定义异常在内部存储其他异常(无法记住为什么这样做),但它的形式是:
public class ContainerException extends Exception {
private List<Exception> innerExeptions = new Arrayist<Exception>();
// some constructors
public void add(Exception e) {
innerExceptions.add(e);
}
public Collection<Exception> getExceptions() {
return innerExceptions;
}
}
它是这样使用的:
try {
// something
} catch (ContainerException ce) {
ce.add(new RunTimeException("some Message");
throw ce; // or do something else
}
在代码的后面,容器异常被评估并转储到日志文件中。
你可以有可能抛出多个不同的异常。例如:
if (obj == null)
throw new NullPointerException();
if (some other case)
throw new IllegalArgumentException();
if (this == this)
throw new IOException();
这段代码可能会抛出多个不同的异常,但这些异常永远不会同时发生。
`try{
...
//some method/action that can be a cause of multiple errors,say X and Y
...
}catch(XException e){
//Do something if exception X arises.
}catch(YException e){
//Do something if exception Y arises.
}
`
ii) 在Java 7之后,您可以使用多重捕获功能。
try{
...
//some method/action that can be a cause of multiple errors,say X and Y
...
}catch(XException|YException e){
// Take action appropriate to both types of exception.
...
}
有一种方法可以使一个方法抛出多个异常,但不能同时抛出。例如,当编译由于某些原因失败时,您的方法只能抛出一个异常。 如果您必须涵盖不同的机会,您可能会声明您的方法抛出所有异常的父类“Exception”。 因此,如果您通常声明一个方法抛出异常,该方法可以抛出任何类型的异常。
例如:
public static void main(String[] args) throws Exception
{
getClipboard(); // throws an UnsupportedFlavorException
initIOActivity(); // throw an IOException
}
public void method() throws UnsupportedSomethingException, IOException {...}
。使用Exception
本身是一种快速失去正确处理异常所获得的大部分能力的方式。我只建议在UI线程或某些顶层捕获异常,以避免完全崩溃。 - indivisible