是否可以在不使用多个catch语句的情况下捕获多个异常并对其执行不同的逻辑？

Question

对于异常执行不同的逻辑。如下：

catch (IOException e | IllegalArgumentException a) {

       e.doStuff();
       a.doStuff();
    }

Answer 1

这没有道理。当您使用 multi catch 时，您就隐含地说：所有“这些”异常都应该落入同一个桶中。

当然，你可以做一些

instanceof

if/else 树，但是哎呀：java 的做法是为每个树都有不同的 catch 语句。

但是，当然，根据上下文，做类似的事情可能是务实的

 catch(XException | YException | ZException  xyOrZ) {
   log(xyOrZ);
   handle(xyOrZ);

其中

handle()

做了一些

instanceof

“切换”。

长话短说：多重捕获是启用适用于所有异常的方面（例如日志记录）的便捷方法。但它可能会妨碍您处理特定于异常的问题。您只需平衡您的需求，并使用您的团队找到的最适合您需求的解决方案。在某种程度上，这是关于 style 的，而 style 问题是由代码库工作人员决定的。

Answer 2

不，你不能那样做。这就是多个

catch

块的用途。

|

形式允许您将不同的异常类型组合在一个

catch

中，但具有异常的公共变量。其目的是允许统一处理不同的异常类型。但是，当您想要不同处理不同类型时，请使用多个

catch

块。

Answer 3

简而言之 - 不。引入了异常的多重捕获，以使用相同的逻辑（如日志记录）连接多个捕获块。所以你想在这里进行逆向工程。

如果您想以不同的方式处理每个异常，请使用旧的表示法：

catch (IllegalArgumentException a) {
     // handle
} catch (IOException e) {
    // handle 
}

在 multicatch 块内执行此操作需要使用 instanceOf，这看起来很恶心并且可读性较差：

catch (IOException | IllegalArgumentException a) {
       if(a instanceof IOException) {
         ((IOException)a).doStuff();
       } else if(a instanceof IllegalArgumentException){
         ((IllegalArgumentException)a).doStuff();
       }

    }

Answer 4

是的，可以在同一个catch块中捕获多个Exception，并根据捕获的Exception执行不同的逻辑。
例如：

catch (IOException | IllegalArgumentException e) {
if(e instanceof IOException){
//execute logic for IOException
}
else if(e instanceof IllegalArgumentException ){
//execute logic for IllegalArgumentException 
}
}

Answer 5

从一段时间以来，您可以使用 lambda 表达式并切换异常：

import java.sql.*;

public class ExceptionLambdaTest
{
    public ExceptionLambdaTest (String param) throws IllegalArgumentException, SQLException
    {
        if (param.equals ("i"))
            throw new IllegalArgumentException ("bad a");
        else if (param.equals ("s"))
            throw new SQLException ("no sql at all");           
    }

    public static void main (String args[])
    {
        String param = "i";
        if (args.length == 1)
        {
            param = args[0];
        }
        try {
            new ExceptionLambdaTest (param);
        } catch (IllegalArgumentException | SQLException isex) {
            System.out.println ("Assuming some common code here.");
            switch (isex)
            {
                case IllegalArgumentException iae -> System.err.println ("i:> " + isex.getMessage ());
                case SQLException se -> System.err.println ("s:> " + isex.getMessage ());
                // case Exception e -> System.err.println ("Unexpected Exception:> " + isex.getMessage ());
                default -> System.err.println ("Unexpected Exception:> " + isex.getMessage ());
            }
        }
    }
}

我没有看到相对于不同的 catch 块的优势，除非你必须做一些常见的事情，这些事情可以在分支到一个语句之前完成。