昨天同事问了一个问题:
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
System.out.println(testException1.testEx());
} catch (Exception e) {
e.printStackTrace();
}
}
}
上边的代码执行的时候,testEx2的方法的catch块的代码会执行,testEx1和testEx方法的catch代码就不执行了。
之前一直没在finally里return过,没出过啥问题,虽然看过几篇关于try-catch-finally相关的文章,但也一直没有在意。调试了一下代码,发现确实是没有执行testEx1和testEx的代码块。
回忆了下之前看到的几篇文章的内容,想到可能是finally的执行时机的问题。finally的执行时机是方法返回之前。分析了一下代码,是这样子滴:
在testEx2中,try中的代码会报错,于是执行catch中的内容,catch的最后一句是抛出一个错误,我们知道在执行这句代码的时候,方法就结束了。但是这个try-catch还有个finally,在执行throw new Exception之前,先执行finally里的代码,而finally里有个return,在finally里直接返回了,throw new Exception也就没执行,testEx2方法也就没有抛出Exception,在testEx1中也就catch不到了,testEx中更catch不到Exception了。
为了验证上边的解释,testEx2的finally的return直接返回true。
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx2, finally; return value=" + ret);
return true;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
System.out.println(testException1.testEx());
} catch (Exception e) {
e.printStackTrace();
}
}
}
调试一下代码可以看到,testEx2会返回true,在testEx1中会执行testEx2返回true的逻辑,testEx也是执行testEx1返回true的逻辑。
最佳实践是在finally中执行一些资源释放,比如关个流,关个连接什么的,不在finally里写return。去掉testEx2,testEx1和testEx方法中finally里的return语句。变成如下的代码:
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
}
return ret;
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx1, finally; return value=" + ret);
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw new Exception();
} finally {
System.out.println("testEx2, finally; return value=" + ret);
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
System.out.println(testException1.testEx());
} catch (Exception e) {
e.printStackTrace();
}
}
}
这时候逻辑就非常好理解了,从testEx2抛出的Exception会一直传递到testEx方法,最终传递到main方法。
finally的执行时机到这就有个大体的概念了,就是方法返回之前(正常返回【return】,异常返回【throw】),执行。下面把这个时间点再精确一点。
运行下面的代码看看:
public class TestFinally {
public static void main(String[] args) {
System.out.println(increment());
}
public static Mode increment() {
Mode t = new Mode();
try {
t.field = 1;
if (t.field == 1) {
throw new NullPointerException();
}
return t;
} catch (Exception e) {
t.field = 7;
return increment2(t);
} finally {
t.field = 3;
}
}
private static Mode increment2(Mode mode) {
mode.field++;
return mode;
}
}
class Mode {
public int field = 4;
@Override
public String toString() {
return String.format("Mode {field=%s}", field);
}
}
上面的代码输入结果是t.a=3。可以看出,increment方法是中的catch中的return,是先执行了increment2方法,然后再执行finally里的代码,最后执行的return。
总结一句,finally是在方法执行返回之前结束。具体的时间粒度可以看上边喽。