Java中try catch finally用法详细实例源码介绍。Java异常处理机制有5个关键字：try，catch，throw，throws，finally。对这几个关键字是这样解释的：
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.
java异常处理之try语句:try后面的大括号{}跟着一段代码，该语句块可能会抛弃一个或多个异常。
java异常处理之catch语句:catch语句的参数类相当于方法的声明，包含异常类型以及异常对象。异常类型必须是Throwable类的子类，指明了catch语句所处理的异常类型，异常对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以多个，用来处理不同的异常类。Java运行时系统从上到下分别对每个catch语句处理的异常类型进行检测，直到找到类型相匹配的catch语句为止。类型匹配指catch所处理的异常类型与生成的异常对象的类型完全一致或者是它的父类，所以catch语句的排列顺序应该是从特殊到一般。也可以用一个catch语句处理多个异常类型，这时它的异常类型参数应该是这多个异常类型的父类，程序设计中要根据具体的情况来选择catch语句的异常处理类型。
java异常处理之finally语句:try所限定的代码中，当抛弃一个异常时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃异常，也无论catch语句的异常类型是否与所抛弃的异常的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。
java异常处理之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!
}
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)
(http://www.blogjava.net/imdosop/archive/2008/10/10/233526.html)
呵呵，看出来了吧。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将被抛弃。