JAVA编程中异常问题处理方式的区别和分析
一、内层方法抛出异常，外层方法捕捉并处理异常：^4J/gC9xVS e
public void methodA (){
MmK G(])a0q
try{
7z6g{%} @]
// 调用methodB
methodB();
} q1P0J'W J Ts
catch(ExceptionType et){ ,K FcN:X/fg7}Wg
I]a LS X;L
// 相应处理措施 l&c.Tz3^ RF Z0y?
k/E Ie Cn-t.b#KA
}
}
public void methodB throws ExceptionType{ g U1u|i0H*Nd'^ ?
[!f'N-~k2eF#d
if (condition is true)
D|L [ Y
{
// 相应处理措施
ums#V$X!oA4L7w
}
else X^;n9E%TP
{ b+b9G5L:O loQ
throw new ExceptionType(argument);
}
} *`"R r4V F7X f
在这个例子中，方法B的头部中声明了该方法会抛出一个类型为ExceptionType的异常，在方法体中使用throw子句抛出了一个异常，那么该异常被谁捕捉到呢，答案是方法A。因为异常抛出后，JVM会顺着该方法的调用栈一层一层的往上找。因为方法A中有一个catch(ExceptionType et),所以被抛出的异常会被捕捉到并处理。
f-E i` d9I I wLS
p M A(x~
二、方法中自己捕捉，处理异常：
p y/M D3X+hx_
public methodA() {
3gu?Rb.g
try
{ ziMq_5Y]
`I!|#k GzH
// 可能产生异常的语句
*w o J5mBt#X/Xg
} S1S(ZHn-X
D6b"v~ }
catch (ExceptionType et)
J/K7p8jsU}As
{
// 相应的处理
}
}
u4a+aD^`,mQ
在这个例子中，方法A使用了try-catch语句块，那么意味着在方法中所产生的ExceptionType类型的异常都会被捕捉到并在方法内处理。 oI't~ a^G@7@)z
8|0O'\|j4o G
三、内层方法抛出一个异常，但本身又有try-catch 3I~$V r$j
public methodB() throws ExceptionType{
try 8| U!c P6Z v h@:L
t'l0ek U3N+J^4l
{
// 可能产生异常的语句 b ra r U gk d3~ ~9K K
} 7F$_Uh9N4J
catch (AnotherExceptionType aet)
'm2s,e Yq M1_.?
{ %NV!nG l/YKC
_m![9V_1T6x
// 相应处理措施
} 2Fb@'y2?)sHC,[
} C VC2[F&^V
3~+J.\qiwr6^ J
在这个例子中有两种异常处理情况，抛出异常和捕捉异常，如果在try语句块中产生ExceptionType类型的异常的话，会被抛出。如果产生AnotherExceptionType类型的话，则不会被抛出，因为在方法B的头部中并没有声明会抛出该异常。
C3nRH9\ j#e
6f/Z/h ] ^}/\7`l
四、内层方法抛出一个异常，但本身有try-finally
public methodB() throws ExceptionType{ (v f(m5i;t
`!I\0{4{d!q8C
try
{ gc K/fI u
// 可能产生异常的语句
Ksy4FU \ LD:q
}
finally
{ A)F d }0v@Q
4ZNioR
// 一定要执行的语句
8vc0OsL+l
}
*Z#Co b F
}
这个例子与上一个例子很像，不同的是没有catch，但增加了finally。它的意思如果方法B中try语句块中如果产生了异常，则抛出由外层方法处理。然后方法B继续执行finally中的语句 \'Q2S7Gn*];L1u
9E7v8C+ty Or9I%V
:[L6y+V[
下面列举三种错误的异常处理方法：
一、内层方法抛出一个异常，但本身有捕捉这个异常 Z-j Y J P9\lU
k Efk `
)_FyQ#G[f
public methodB() throws ExceptionType{
@/zY!L O(Kq
try 9t`]L9VBy3C q
{
x Z8~\GL]W(~
// 可能产生异常的语句
} )l&?0lD#q-Yt6`
catch (ExceptionType et) T4CP8Jr{ } X
{ +h j] o,no;M
oOlBwe,rh
// 相应处理措施
}
3z,Zj%s j:h7^%V.G
}
在这个例子中，方法B在头部声明了会抛出一个类型为ExceptionType的异常，但在紧接下来的方法体又用了catch(ExceptionType et),如果产生了异常的话，会有什么结果呢？方法B抛出的异常马上被自身的catch捕捉到，所以方法头部的throws实际是没有作用的。外层方法是接收不到方法B抛出的异常对象的。
O2Yj6P.f'x-`m
0c9p4]O{%J^6] KH
二、在try中使用了return,在fianlly中又使用了return f,w#n OG)h-Ge
:z@'CFN}*Uf
public methodB() {
b}!a c.YT6s}R"R
j r:c,Y8Fz*i
try
r5_{|NX g h
{
// 可能产生异常的语句
!QZv_EZp3m
return SOMEVALUE;
}
catch ()
{ E*`xk)bmM6QL;r
}
finally 4F6z S{ cp.g
G8{-u l1h[1k/i"a Rv
{ 9V O"u$qyx X8Pe
return SOMEVALUE_2; ~W%\2VQ5x It)Y
}
}
在这个例证中，我们可以看到在try中返回了SOMEVALUE，那么程序执行到这里是否就结束了呢，其实不是的，因为finally中的语句是肯定会被执行到的，所以最后返回的是SOMEVALUE_2;那么意味者即使程序没有抛出异常，最后也得不到正确的结果。
O+xlc`d
)G n)G0A+Q V;R
三、把catch(Exception e)放在所有catch块的最前面
public methodB(){ R h8\6F,B(s?.QH
D^ u.gR&C
try %W R2[S1sm/j h$[9R
d$`c"v{!Lw
{ J2|7Qdl4|'O
h1G0cQ CZw#ny
Lf@E{(V4h|#t
}
K-g\\"N
catch (Exception e) &@5rj*PE%Tu
?'u8h:P7kb
{ X F6t/u0~ j|^;Wim
G%KE Z pnf(r`*I
... p~1hnH/kZ
b tNS L{.^!ol
}
catch (SubException se)
!Pd+| Vv `0p O)a
{
)w|7|\ @
... 5HG:k n,rNR
} ,K1o@ w:v#@0cr
+?9x+nF{8u$f
1]G(p`*t.Qc
}
7h0F v {4e4DJ Y;{7}
在这个例子中，catch(Exception e)被放在所有catch语句块的最前面，因为Exception所有Exception类型的父类，所以意味着所有在try中产生的异常都会被捕捉到。后面其他的catch都是没有用的，所以一定要把catch(Exception e)放在最后面，如果前面所有的异常类型都不符合，至少保证还有一个可以处理它。 &U7E$BCO%n
0tv"Q0sC8a$E
总结： 2D0y&Bw9}0af%t+Z
A．如果能够找到一个有意义的方法来捕获异常，就立即引入这个方法
4BSsf L0q-?7K;s w[ a
B．否则就应该考虑做某些处理后传递或者再次抛出异常，也可以把异常转换为另一种形式，然后抛出一个新的异常 W p @1h/C9Q!o6b
C．另一个方法是，可以完全忽略这个异常，而把它加到方法的头部的throws语句中，由调用这个方法的方法来处理它
s:g2V+H__7l SU
D．通过捕获一个公共的异常超类，可以在一个块里面捕获多个异常，但不能够用一个空的catch语句 块来完全制止一个异常。
页:
[1]