Java异常处理详解

首先解释一下try catch finally的用法：

1、try+catch 
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句 

2、try+catch+finally 
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。
如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句 

3、try+finally 
程序的流程是：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了。

demo1：

[java]  view plain  copy

 print ?

1. package test.java.example;  
2.   
3. /** 
4.  * Created by hejingyuan on 2016/5/2. 
5.  */  
6. public class TestCatchException {  
7.     public TestCatchException() {  
8.     }  
9.   
10.     boolean testEx1() {  
11.         boolean ret = true;  
12.         try {  
13.             ret = testEx2();  
14.             if (!ret) {  
15.                 return false;  
16.             }  
17.             System.out.println("testEx1, at the end of try");  
18.         } catch (Exception e) {  
19.             System.out.println("testEx1, catch exception");  
20.             ret = false;  
21.         }  
22.         return ret;  
23.     }  
24.   
25.     boolean testEx2(){  
26.         boolean ret = true;  
27.         try {  
28.             int b = 12;  
29.             int c;  
30.             for (int i = 2; i >= -2; i--) {  
31.                 c = b / i;  
32.                 System.out.println("i=" + i);  
33.             }  
34.             ret = true;  
35.         } catch (Exception e) {  
36.             System.out.println("testEx2, catch exception");  
37.             ret = false;  
38.         }  
39.         return ret;  
40.     }  
41.   
42.     public static void main(String[] args) {  
43.         TestCatchException testException1 = new TestCatchException();  
44.         try {  
45.             testException1.testEx1();  
46.         } catch (Exception e) {  
47.             e.printStackTrace();  
48.         }  
49.     }  
50. }  

执行结果：

i=2
i=1
testEx2, catch exception

原因：在testEx2方法中已经catch住了异常（执行catch方法），即将异常自己处理掉了，然后继续往下执行返回，所以在testEx1中并不会有任何异常出现，也就不会执行catch代码块，而是走try的正常流程，经过if判断直接返回false

demo2：

[java]  view plain  copy

 print ?

1. package test.java.example;  
2.   
3. /** 
4.  * Created by hejingyuan on 2016/5/2. 
5.  */  
6. public class TestThrowException {  
7.     public TestThrowException() {  
8.     }  
9.   
10.     boolean testEx() throws Exception {  
11.         boolean ret = true;  
12.         try {  
13.             ret = testEx1();  
14.             return ret;  
15.         } catch (Exception e) {  
16.             System.out.println("testEx, catch exception");  
17.             ret = false;  
18.             throw e;  
19.         } finally {  
20.             System.out.println("testEx, finally; return value=" + ret);  
21.         }  
22.     }  
23.   
24.     boolean testEx1() throws Exception {  
25.         boolean ret = true;  
26.         try {  
27.             ret = testEx2();  
28.             if (!ret) {  
29.                 return false;  
30.             }  
31.             System.out.println("testEx1, at the end of try");  
32.             return ret;  
33.         } catch (Exception e) {  
34.             System.out.println("testEx1, catch exception");  
35.             ret = false;  
36.             throw e;  
37.         } finally {  
38.             System.out.println("testEx1, finally; return value=" + ret);  
39.         }  
40.     }  
41.   
42.     boolean testEx2() throws Exception {  
43.         boolean ret = true;  
44.         try {  
45.             int b = 12;  
46.             int c;  
47.             for (int i = 2; i >= -2; i--) {  
48.                 c = b / i;  
49.                 System.out.println("i=" + i);  
50.             }  
51.             return true;  
52.         } catch (Exception e) {  
53.             System.out.println("testEx2, catch exception");  
54.             ret = false;  
55.             throw e;  
56.         } finally {  
57.             System.out.println("testEx2, finally; return value=" + ret);  
58.         }  
59.   
60.     }  
61.     public static void main(String[] args) {  
62.         TestThrowException testException1 = new TestThrowException();  
63.         try {  
64.             testException1.testEx();  
65.         } catch (Exception e) {  
66.             e.printStackTrace();  
67.         }  
68.     }  
69. }  

执行结果:

i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
java.lang.ArithmeticException: / by zero
at test.java.example.TestThrowException.testEx2(TestThrowException.java:48)
at test.java.example.TestThrowException.testEx1(TestThrowException.java:27)
at test.java.example.TestThrowException.testEx(TestThrowException.java:13)
at test.java.example.TestThrowException.main(TestThrowException.java:64)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:606)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

原因：在testEx2方法中出现除数为0时会抛出异常，然后由catch捕获到，故执行catch部分，打印并抛出异常，然后执行finally打印信息，由于catch中抛出了异常，所以上层方法将会执行catch部分，即testEx1方法将执行catch部分，之后异常还是会继续往上层抛出，到testEx方法并不会执行返回仍然catch住异常然后抛给main函数的catch，然后打印出来

demo3:

[java]  view plain  copy

 print ?

1. package test.java.example;  
2.   
3. public class TestException {  
4.     public TestException() {  
5.     }  
6.   
7.     boolean testEx() throws Exception {  
8.         boolean ret = true;  
9.         try {  
10.             ret = testEx1();  
11.         } catch (Exception e) {  
12.             System.out.println("testEx, catch exception");  
13.             ret = false;  
14.             throw e;  
15.         } finally {  
16.             System.out.println("testEx, finally; return value=" + ret);  
17.             return ret;  
18.         }  
19.     }  
20.   
21.     boolean testEx1() throws Exception {  
22.         boolean ret = true;  
23.         try {  
24.             ret = testEx2();  
25.             if (!ret) {  
26.                 return false;  
27.             }  
28.             System.out.println("testEx1, at the end of try");  
29.             return ret;  
30.         } catch (Exception e) {  
31.             System.out.println("testEx1, catch exception");  
32.             ret = false;  
33.             throw e;  
34.         } finally {  
35.             System.out.println("testEx1, finally; return value=" + ret);  
36.             return ret;  
37.         }  
38.     }  
39.   
40.     boolean testEx2() throws Exception {  
41.         boolean ret = true;  
42.         try {  
43.             int b = 12;  
44.             int c;  
45.             for (int i = 2; i >= -2; i--) {  
46.                 c = b / i;  
47.                 System.out.println("i=" + i);  
48.             }  
49.             return true;  
50.         } catch (Exception e) {  
51.             System.out.println("testEx2, catch exception");  
52.             ret = false;  
53.             throw e;  
54.         } finally {  
55.             System.out.println("testEx2, finally; return value=" + ret);  
56.             return ret;  
57.         }  
58.     }  
59.   
60.     public static void main(String[] args) {  
61.         TestException testException1 = new TestException();  
62.         try {  
63.             testException1.testEx();  
64.         } catch (Exception e) {  
65.             e.printStackTrace();  
66.         }  
67.     }  
68. }  

执行结果：

i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false

原因:

（假设方法需要返回值）
java 的异常处理中，
在不抛出异常的情况下，程序执行完 try 里面的代码块之后，该方法并不会立即结束，而是继续试图去寻找该方法有没有 finally 的代码块，
如果没有 finally 代码块，整个方法在执行完 try 代码块后返回相应的值来结束整个方法；
如果有 finally 代码块，此时程序执行到 try 代码块里的 return 语句之时并不会立即执行 return，而是先去执行 finally 代码块里的代码，
若 finally 代码块里没有 return 或没有能够终止程序的代码，程序将在执行完 finally 代码块代码之后再返回 try 代码块执行 return 语句来结束整个方法；
若 finally 代码块里有 return 或含有能够终止程序的代码，方法将在执行完 finally 之后被结束，不再跳回 try 代码块执行 return。
在抛出异常的情况下，原理也是和上面的一样的，你把上面说到的 try 换成 catch 去理解就 OK 了 *_*，即catch中无论是返回还是抛出异常，最终返回的均是finally中的结果，除非finally无返回。