Question

当我执行以下代码时

1.    public class test {
2.      public static void main(String[] args) {
3.          try {
4.              int i = 10 / 0;
5.          } catch (Exception e) {
6.              int j = 10 / 0;
7.          } finally {
8.              int k = 10 / 0;
9.          }
10.     }
11.    }

我收到错误：

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at test.main(test.java:8)

我没有理解为什么JVM从main（）而不是catch块抛出异常。

Answer 1

如果你遵循the step-by-step description of a try-catch-finally in the JLS，你会看到（总结）如果catch抛出异常然后最终被执行并且（强调我的）：

如果catch块因为R而突然完成，则执行finally块。

如果finally块突然完成因为原因S ，那么try语句突然完成因为原因S （并且原因R被丢弃）。

因此，catch块抛出的异常（在finally块之前执行）被丢弃，报告的异常是finally块中抛出的异常。

Answer 2

因为在每个块中 - 尝试/ catch /最后你有一个除零。在catch中添加另一个try-catch块并在catch中报告错误。

例如：

public class test {
    public static void main(String[] args) {
        try {
            int i = 10 / 0;
        } catch (Exception e) {
            try {
                int j = 10 / 0;
            } catch (Exception e) {
                // report an error here - do not do any business logic
            }
        } finally {
            int k = 10 / 0;
        }
    }
}

Answer 3

需要注意的一件有趣的事情是，如果您在finally语句中对代码进行注释，则ArithmeticException引发的内容将涉及catch语句中的代码。

我相信这里发生的事情是，Exception语句中应该抛出的catch被忽略，因为 Exception被抛出{ {1}}陈述。

Answer 4

例外

in  } catch (Exception e) {
              int j = 10 / 0;
             }

将抛出最终阻止，如果你删除finally块，你将得到一个

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at test.main(test.java:6)

catch块中的所有异常都将被抛出到finally块也最后阻止将以任何方式执行

Answer 5

try 
{
     System.out.println("Try block 1");
     int i = 10 / 0; //First Exception
     System.out.println("Try block 2");
 } catch (Exception e) { //Catched the first Exception
      System.out.println("Catch block 1");
      int j = 10 / 0; //Again Exception -->  Who will catch this one
      System.out.println("Catch block 2");
 } finally {
       System.out.println("finally block 1");
       int k = 10 / 0; //Again Exception -->  Who will catch this one
       System.out.println("finally block 2");
 }

如果try块中发生异常，则该异常由与之关联的异常处理程序处理。要将异常处理程序与try块关联，必须在其后面放置一个catch块。

通过在try块之后直接提供一个或多个catch块，将异常处理程序与try块关联。

每个catch块都是一个异常处理程序，它处理由其参数

指示的异常类型

当try块退出时，finally块始终执行。

Answer 6

在Java异常处理中，无论是否捕获到异常，但如果您使用了 finally 块，它将始终执行。

因此，您在代码中所做的是 -

从main（）
捕获catch块中的异常
将catch块中捕获的异常捕获到finally块（无论如何都会执行！）

在此代码中，要么只使用catch，要么只使用finally，以获得正确的结果。

并且，既然你想在catch中捕获异常，最后省略，只需使用catch。

通过Catch Block进行Java异常处理

6 个答案: