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无返回。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值