Java中的try catch finally

 

Java中的try catch finally

Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：

Throws:  Lists the exceptions a method could throw.

Throw:   Transfers control of the method to the exception handler.

Try：    Opening exception-handling statement.

Catch：  Captures the exception.

Finally： Runs its code before terminating the program.

1.try语句:try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。

2.catch语句:catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语

句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。

catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹

配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺

序应该是从特殊到一般。也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据

具体的情况来选择catch语句的例外处理类型。　

3.finally语句:try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序

块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出

口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

4.throws语句:throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫

你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException， 或它们的子类，这个规则不起作用， 因为这在

程序的正常部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

5.throw语句:throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有

try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

 

浏览try catch finally一点疑惑时，发现JAVA中的异常还挺有意思的，于是写了如下的代码，研究一下：

public class ExceptionDemo {

    public int testTryReturn() {

       // 执行顺序为try中输出语句-try中return(1入栈)-finally输出-try中1出栈

       try {

           System.out.println("TestTryReturn---");

           return 1;

       } finally {

           System.out.println("Finally block.");

       }

    }

    @SuppressWarnings("finally")

    public int testFinallyReturn1() {

       // 由此可以看出，finally中的return比try中的return优先级高

       try {

           System.out.println("TestFinallyReturn1--");

           return 1;

       } finally {

           System.out.println("Finally block.");

           return 2;

       }

    }

    @SuppressWarnings("finally")

    public int testFinallyReturn2() {

       // 执行顺序为try中输出语句-finally中输出语句-finally中return

       try {

           System.out.println("TestFinallyReturn2--");

       } finally {

           System.out.println("Finally block.");

           return 2;

       }

       // return 1; Error!

    }

    @SuppressWarnings("finally")

    public int testReturn() {

       // 执行顺序为try中输出语句-finally中return

       try {

           System.out.println("TestReturn--");

           return 1;

       } catch (Exception e) {

           return 2;

       } finally {

           return 3;

       }

    }

    @SuppressWarnings("finally")

    public int testCatchReturn() {

       // 执行顺序为try中输出语句-catch块2压栈-finally中return

       try {

           System.out.println("TestCatchReturn---");

           System.out.println(5 / 0);

       } catch (Exception e) {

           return 2;

       } finally {

           return 3;

       }

    }

    public int testCatchReturn2() {

       // 执行顺序为try中输出语句-catch块2压栈-finally中输出语句-catch块2出栈

       try {

           System.out.println("TestCatchReturn2---");

           System.out.println(5 / 0);

           return 1;

       } catch (Exception e) {

           return 2;

       } finally {

           System.out.println("Finally block.");

       }

       // return 0; Error!

    }

    /**

     * @param args

     */

    public static void main(String[] args) {

       try {

           // 异常try-catch

           System.out.println(5 / 0);

       } catch (Exception e) {

           System.out.println("Catch exception 1.");

           // 异常try-catch-finally

           try {

              System.out.println(5 / 0);

           } catch (Exception ex) {

              System.out.println("Catch exception 2.");

           } finally {

              System.out.println("Finally block @.");

              // 无异常try-catch-finally

              try {

                  System.out.println("Test---");

              } catch (Exception ex) {

                  System.out.println("Catch exception 3.");

              } finally {

                  System.out.println("Finally block #.");

                  // 异常try-finally

                  try {

                     System.out.println(5 / 0);

                  } finally {

                     System.out.println("Finally block $.");

                     // 无异常try-finally

                     try {

                         System.out.println("Normal");

                     } finally {

                         System.out.println("Finally block %.");

                     }

                  }

              }

           }

       } finally {

           // 有return语句的情况

           ExceptionDemo demo = new ExceptionDemo();

           try {

              System.out.println(demo.testCatchReturn());

           } finally {

              try {

                  System.out.println(demo.testFinallyReturn1());

              } finally {

                  try {

                     System.out.println(demo.testFinallyReturn2());

                  } finally {

                     try {

                         System.out.println(demo.testReturn());

                     } finally {

                         System.out.println(demo.testTryReturn());

                         System.out.println(demo.testCatchReturn2());

                     }

                  }

              }

           }

       }

    }

}

Catch exception 1.

Catch exception 2.

Finally block @.

Test---

Finally block #.

Finally block $.

Normal

Finally block %.

TestCatchReturn---

3

TestFinallyReturn1--

Finally block.

2

TestFinallyReturn2--

Finally block.

2

TestReturn--

3

TestTryReturn---

Finally block.

1

TestCatchReturn2---

Finally block.

2

Exception in thread "main" java.lang.ArithmeticException: / by zero

at ExceptionDemo.main(ExceptionDemo.java:105)

呵呵，看出来了吧。try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。

try-catch程序块的执行流程以及执行结果

相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1.如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。

2.如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。

3.如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。

 

try-catch-finally程序块的执行流程以及执行结果

try-catch-finally程序块的执行流程以及执行结果比较复杂。首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1.如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：

       1)如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

       2)如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”

2.如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：

       如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：

       如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

       如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”

       如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：

       如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。

       如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。

       如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：

       如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。

       如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。

3.如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：

       如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。

       如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。

 

 

出处：http://hanhongke123.blog.163.com/blog/static/62223494201110710318430/