我可以在同一catch子句中捕获多个Java异常吗？

在Java中，我想做这样的事情：

try {
    ...     
} catch (/* code to catch IllegalArgumentException, SecurityException, 
            IllegalAccessException, and NoSuchFieldException at the same time */) {
   someCode();
}

...代替：

try {
    ...     
} catch (IllegalArgumentException e) {
    someCode();
} catch (SecurityException e) {
    someCode();
} catch (IllegalAccessException e) {
    someCode();
} catch (NoSuchFieldException e) {
    someCode();
}

有什么办法吗？

从Java 7开始，这已经成为可能。多捕获块的语法为：

try { 
  ...
} catch (IOException | SQLException ex) { 
  ...
}

但是请记住，如果所有异常都属于同一类层次结构，则可以简单地捕获该基本异常类型。

还要注意，如果从ExceptionA直接或间接继承了ExceptionB，则不能在同一块中同时捕获ExceptionA和ExceptionB。编译器会抱怨：

Alternatives in a multi-catch statement cannot be related by subclassing
  Alternative ExceptionB is a subclass of alternative ExceptionA

不完全是在Java 7之前，但我会做这样的事情：

Java 6及更低版本

try {
  //.....
} catch (Exception exc) {
  if (exc instanceof IllegalArgumentException || exc instanceof SecurityException || 
     exc instanceof IllegalAccessException || exc instanceof NoSuchFieldException ) {

     someCode();

  } else if (exc instanceof RuntimeException) {
     throw (RuntimeException) exc;     

  } else {
    throw new RuntimeException(exc);
  }

}

Java 7

try {
  //.....
} catch ( IllegalArgumentException | SecurityException |
         IllegalAccessException |NoSuchFieldException exc) {
  someCode();
}

在Java 7中，您可以定义多个catch子句，例如：

catch (IllegalArgumentException | SecurityException e)
{
    ...
}

如果存在异常层次结构，则可以使用基类捕获异常的所有子类。在简并的情况下，您可以使用以下命令捕获所有 Java异常：

try {
   ...
} catch (Exception e) {
   someCode();
}

在更常见的情况下，如果RepositoryException是基类，而PathNotFoundException是派生类，则：

try {
   ...
} catch (RepositoryException re) {
   someCode();
} catch (Exception e) {
   someCode();
}

上面的代码将捕获RepositoryException和PathNotFoundException以进行一种异常处理，并将所有其他异常组合在一起。从Java 7开始，按照上述@OscarRyz的回答：

try { 
  ...
} catch( IOException | SQLException ex ) { 
  ...
}

不，每个客户一个。

只要在所有情况下都执行相同的操作，就可以捕获一个超类，例如java.lang.Exception。

try {
    // some code
} catch(Exception e) { //All exceptions are caught here as all are inheriting java.lang.Exception
    e.printStackTrace();
}

但这可能不是最佳做法。您只有在具有实际处理策略的情况下才应捕获异常-记录和重新抛出不是“处理”。如果您没有采取纠正措施，则最好将其添加到方法签名中，然后让其冒充可以处理这种情况的人员。

在Java 6（即Android）上，替代user454322的答案的更简洁（但不太冗长，也许不是首选）的方法是捕获所有Exceptions并重新抛出RuntimeExceptions。如果您打算在堆栈中进一步捕获其他类型的异常（除非您也将它们重新抛出），则此方法将行不通，但将有效地捕获所有已检查的异常。

例如：

try {
    // CODE THAT THROWS EXCEPTION
} catch (Exception e) {
    if (e instanceof RuntimeException) {
        // this exception was not expected, so re-throw it
        throw e;
    } else {
        // YOUR CODE FOR ALL CHECKED EXCEPTIONS
    } 
}

话虽这么说，对于冗长而言，最好设置一个布尔值或其他变量，并根据该变量在try-catch块之后执行一些代码。

在7之前的版本中：

  Boolean   caught = true;
  Exception e;
  try {
     ...
     caught = false;
  } catch (TransformerException te) {
     e = te;
  } catch (SocketException se) {
     e = se;
  } catch (IOException ie) {
     e = ie;
  }
  if (caught) {
     someCode(); // You can reference Exception e here.
  }

是。这是使用pipe（|）分隔符的方法，

try
{
    .......
}    
catch
{
    catch(IllegalArgumentException | SecurityException | IllegalAccessException | NoSuchFieldException e)
}

对于Kotlin来说，目前尚不可能，但他们已经考虑添加它：Source
但现在，这只是一个小技巧：

try {
    // code
} catch(ex:Exception) {
    when(ex) {
        is SomeException,
        is AnotherException -> {
            // handle
        }
        else -> throw ex
    }
}

在异常层次结构中捕获恰好是父类的异常。这当然是坏习惯。在您的情况下，常见的父异常恰好是Exception类，并且捕获作为Exception实例的任何异常确实是不好的做法-像NullPointerException这样的异常通常是编程错误，通常应通过检查null值来解决。