之前,在使用异常捕获语句try...catch...throw语句时,一直没太留意几种用法的区别,前几天调试程序时无意中了解到几种使用方法是有区别的,网上一查,还真是,主要是区别在堆栈信息的起始点不同。总结如下:
一、异常处理过程
异常是发生在函数域的,函数内部发生异常:
1. 如果有try-catch处理,则跳到catch处理完毕,再继续执行catch后面的语句块。
2. 如果没有异常处理,则往上抛。如果调用方也没有异常处理,则继续往函数栈上抛,直到最外层函数,如果应用程序级别也没有处理,则由操作系统捕获到程序发生错误,结束程序
二、throw几种方式的区别
throw;可追溯到原始异常点,获取所有异常(范围粒度较大) (编译器会警告,定义的ex未有使用)推荐位置2
throw ex;会将到现在为止的所有信息清空,认为你catch到的异常已经被处理了,只不过处理过程中又抛出新的异常,从而找不到真正的错误源。X
throw new Exception("errstr",ex);经过对异常重新包装,会保留原始异常点信息。推荐位置1
三、try catch finally的执行顺序(有return的情况下)
结论:
1、不管有木有出现异常,finally块中代码都会执行;
2、当try和catch中有return时,finally仍然会执行;
3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,管finally中的代码怎么样,返回的值都不会改变,任然是之前保存的值),所以函数返回值是在finally执行前确定的;
4、finally中最好不要包含return,否则程序会提前退出,返回值不是try或catch中保存的返回值。
四、throw例子:
第一种(不推荐使用,可惜很多人都一直这么用的,包括俺,嘻嘻),这样适用会吃掉原始异常点,重置堆栈中的异常起始点:
View Code
try
{
}
catch (Exception ex)
{
throw ex;
}
第二种,可追溯到原始异常点,不过编译器会警告,定义的ex未有使用:
View Code
try
{
}
catch (Exception ex)
{
throw;
}
第三种,不带异常参数的,这个同第二种其实一样,可捕获所有类型的异常,IDE不会告警:
View Code
try
{
}
catch
{
throw;
}
其实第二种和第三种用法,书上也是不建议使用的,一般要从小粒度的异常捕获开始,采用多个catch语句,大家就见仁见智吧。。。
第四种:经过对异常重新包装,但是会保留原始异常点信息。推荐使用。
View Code
try
{
}
catch (Exception ex)
{
throw new Exception("经过进一步包装的异常", ex);
}
下面用个例子来加以说明:
View Code
1 /// <summary>
2 /// 入口方法
3 /// </summary>
4 public static void Main()
5 {
6 ExceptionClass ec = new ExceptionClass();
7
8 try
9 {
10 ec.ExceptionThrow1();
11 }
12 catch (Exception ex)
13 {
14 Console.WriteLine(ex.ToString());
15 }
16
17 Console.WriteLine("---------------------------------------------------------------------");
18
19 try
20 {
21 ec.ExceptionThrow2();
22 }
23 catch (Exception ex)
24 {
25 Console.WriteLine(ex.ToString());
26 }
27
28 Console.WriteLine("---------------------------------------------------------------------");
29
30 try
31 {
32 ec.ExceptionThrow3();
33 }
34 catch (Exception ex)
35 {
36 Console.WriteLine(ex.ToString());
37 }
38
39 Console.WriteLine("---------------------------------------------------------------------");
40
41 try
42 {
43 ec.ExceptionThrow4();
44 }
45 catch (Exception ex)
46 {
47 Console.WriteLine(ex.ToString());
48 }
49
50 Console.WriteLine("---------------------------------------------------------------------");
51
52 Console.ReadKey();
53 }
54 }
55
56 /// <summary>
57 /// 该Class用来测试异常抛出时相关上下文栈的调用情况
58 /// </summary>
59 public class ExceptionClass
60 {
61 /// <summary>
62 /// 抛出异常方法
63 /// </summary>
64 public void ExceptionThrow1()
65 {
66 try
67 {
68 // 调用原始异常抛出方法来抛出异常
69 this.ExceptionMethod();
70 }
71 catch (Exception ex)
72 {
73 throw ex;
74 }
75 }
76
77 /// <summary>
78 /// 抛出异常方法1
79 /// </summary>
80 public void ExceptionThrow2()
81 {
82 try
83 {
84 this.ExceptionMethod();
85 }
86 catch (Exception ex)
87 {
88 throw;
89 }
90 }
91
92 /// <summary>
93 /// 抛出异常方法2
94 /// </summary>
95 public void ExceptionThrow3()
96 {
97 try
98 {
99 this.ExceptionMethod();
100 }
101 catch
102 {
103 throw;
104 }
105 }
106
107 /// <summary>
108 /// 抛出异常方法3
109 /// </summary>
110 public void ExceptionThrow4()
111 {
112 try
113 {
114 this.ExceptionMethod();
115 }
116 catch (Exception ex)
117 {
118 throw new Exception("经过进一步包装的异常", ex);
119 }
120 }
121
122 /// <summary>
123 /// 原始异常抛出方法
124 /// </summary>
125 private void ExceptionMethod()
126 {
127 throw new DivideByZeroException();
128 }
129 }
运行结果如下:
从运行的结果可以看到,第一种用法已经吃掉了原始异常信息。而其它3种用法都可以追溯到原始异常,推荐使用第四种用法,希望大家能了解这些细微的差别,享受Coding的乐趣吧...
五、try catch finally 举例:
情况1:try{} catch(){}finally{} return;
显然程序按顺序执行。
情况2:try{ return; }catch(){} finally{} return;
程序执行try块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,最后执行try中return;
finally块之后的语句return,因为程序在try中已经return所以不再执行。
情况3:try{ } catch(){return;} finally{} return;
程序先执行try,如果遇到异常执行catch块,
有异常:则执行catch中return之前(包括return语句中的表达式运算)代码,再执行finally语句中全部代码,
最后执行catch块中return. finally之后也就是4处的代码不再执行。
无异常:执行完try再finally再return.
情况4:try{ return; }catch(){} finally{return;}
程序执行try块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,因为finally块中有return所以提前退出。
情况5:try{} catch(){return;}finally{return;}
程序执行catch块中return之前(包括return语句中的表达式运算)代码;
再执行finally块,因为finally块中有return所以提前退出。
情况6:try{ return;}catch(){return;} finally{return;}
程序执行try块中return之前(包括return语句中的表达式运算)代码;
有异常:执行catch块中return之前(包括return语句中的表达式运算)代码;
则再执行finally块,因为finally块中有return所以提前退出。
无异常:则再执行finally块,因为finally块中有return所以提前退出。
最终结论:任何执行try 或者catch中的return语句之前,都会先执行finally语句,如果finally存在的话。
如果finally中有return语句,那么程序就return了,所以finally中的return是一定会被return的,
编译器把finally中的return实现为一个warning。
下面是个测试程序 public class FinallyTest { public static void main(String[] args) { System.out.println(new FinallyTest().test());; } static int test() { int x = 1; try { x++; return x; } finally { ++x; } } } 结果是2。
分析:
在try语句中,在执行return语句时,要返回的结果已经准备好了,就在此时,程序转到finally执行了。 在转去之前,try中先把要返回的结果存放到不同于x的局部变量中去,执行完finally之后,在从中取出返回结果, 因此,即使finally中对变量x进行了改变,但是不会影响返回结果。 它应该使用栈保存返回值。