Question

在JAVA中进行异常处理练习时，我对各种事情感到困惑。基本上我不明白的是当遇到异常时程序的流程如何。我想了解程序的流程实际上是如何在以下场景中进行的，以及我对这些概念的理解是对还是错。

 public void myFunction(){

     try{

            //Some code......

        }catch(Exception e1){

            //If this Exception is occured handle it here.

        }catch(Exception e2){

           //if this exception has occured then

          throw new myException("whatever message required");
        }

       finally{

           //code that has to be executed 
       }

 }

现在我的理解是：

1.如果没有异常发生，则代码运行平稳，最终执行finally块中的代码 2.如果发生异常e1，那么它会被捕获到第一个catch块中，它会在那里被适当地处理，然后最终块被执行。但是如果发生异常e2会发生什么。在那个catch块中我们抛出一个新的异常。所以我调用myFunction的方法应该提供一些处理它的机制 myException？所以执行将转移到调用方法的catch块。对吗？那么myFunction（）的“finally”块会发生什么？它不会被执行呢？如何进行程序流程？我真的很难发现当我们使用“throw”时会发生什么。我们使用它时会发生什么？

Answer 1

请参阅（您的已修改示例）：

try {
  // Some code ...
}
catch(SomeException e1) {
  // SomeException code ...
}
catch(SomeOtherException e2) { // SomeOtherException is NOT SomeException extension
  throw new myException("whatever message required");
}
finally {
  // Some final code ...
}

执行可能性：

 1. No exception at all:
   Some code executed
   Some final code executed
 2. SomeException is thrown:
   Some code (may be partially) executed  
   SomeException code executed
   Some final code executed
 3. SomeOtherException is thrown:
   Some code (may be partially) executed
   Some final code executed
   throw new myException("whatever message required");
 4. SomeStrangeException is thrown 
   Some code (may be partially) executed 
   Some final code executed
   System'll look for other try {} catch {} block to catch SomeStrangeException

Answer 2

考虑下面的例子（Basicalliy你的例子只是填充了一些真正的代码，它被设计为抛出NullPointerException）：

public class Exceptions {

    public static void myMethod() {
        try{
            String s = null;
            s.length();
        }
        catch(NumberFormatException e1){
            System.out.println("Something unexpected happend");
        }
        catch(NullPointerException e2){
            throw new RuntimeException("Exactly what we want happened");
        }
        finally{
            System.out.println("Finally Block");
        }
    }

    public static void main(String[] args){
        try{
            myMethod();
        }
        catch(RuntimeException e){
            e.printStackTrace();
        }
    }
}

其输出为：

Finally Block
java.lang.RuntimeException: Exactly what we want happened
    at Exceptions.myMethod(Exceptions.java:14)
    at Exceptions.main(Exceptions.java:23)

所以你可以看到，在将新的RuntimeException传递给调用方法之前执行finally块。否则，“Finally Block”输出将在RuntimeException的堆栈跟踪之后。

Answer 3

＆＃34;我调用myFunction的方法应该提供一些机制来处理这个myException？＆＃34; 它应该，但只有当myException扩展了已检查的异常时，编译器才会让你这样做。无论发生什么，最终块将始终执行。

Answer 4

在Java Language Specification, section 11.3

中可以找到有关如何在运行时处理Java异常的一切知识。

本质上，当遇到异常时，程序流停止并且控制向上传递到调用堆栈，直到异常被try/catch捕获或直到异常到达堆栈的底部，此时线程被终止。

所以换句话说，＆＃34;发生了一些事情，停止你正在做的事情，转到最接近匹配此异常的catch块，除非没有catch块，在这种情况下杀死线程＆＃34;

在您的情况下，e2将永远不会发生，因为所有例外已被第一个catch块捕获。如果您想要以不同方式处理不同的异常，通常会使用多个catch块，例如例如，如果要解析文件中的数字，则在一个块中捕获IOException，在另一个块中捕获NumberFormatException。

您不必处理运行时异常（扩展RuntimeException的异常）。您必须明确处理已检查的异常（扩展Exception但不是RuntimeException的异常）。

无论是否抛出异常，finally块中的代码都会被执行。

Answer 5

这将有助于您更好地理解catch块

http://www.c4learn.com/java/java-multiple-catch-blocks/

此外，在java 7中，支持多异常捕获：

try {
 // stuff
} catch (Exception1 | Exception2 ex) {
 // Handle both exceptions
}

理解JAVA中的throw关键字

5 个答案: