3

当我执行以下代码时

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 块抛出异常的原因。

4

6 回答 6

2

如果您按照JLS 中 try-catch-finally 的分步描述，您会看到（总而言之）如果 catch 抛出异常，则 finally 被执行并且（强调我的）：

如果 catch 块由于原因 R 突然完成，则执行 finally 块。

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

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

于 2013-07-31T10:25:31.560 回答
1

例外

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

将被抛出到 finally 块，如果你删除 finally 块，你会得到一个

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

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

于 2013-07-31T10:34:36.037 回答
1

因为在每个块中 - try/catch/finally 你都会被零除。在 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;
        }
    }
}
于 2013-07-31T10:22:19.950 回答
1 
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 块都是一个异常处理程序，并处理由其参数指示的异常类型

finally 块总是在 try 块退出时执行。

于 2013-07-31T10:49:04.557 回答
1

需要注意的一件有趣的事情是，如果您在finally语句中注释代码，则ArithmeticException抛出的将涉及catch语句中的代码。

我相信这里发生的事情是Exception，应该在你的catch陈述中抛出的那个被忽略了，因为Exception你的陈述中抛出了一个finally。

于 2013-07-31T10:25:09.887 回答
0

在 Java 异常处理中，不管异常是否被捕获，但如果你使用了finally块，它总是会被执行。

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

  1. 从 main() 抛出异常对象
  2. 在 catch 块中捕获异常
  3. 将 catch 块中捕获的异常抛出到 finally 块（无论如何它都会被执行！）

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

并且，由于您希望在 catch 中捕获异常，因此最后省略，只需使用 catch。

祝你好运！

于 2013-07-31T10:44:04.857 回答