当程序不想给上层抛出异常，或者说想捕获异常时，通常我们会使用到try， catch ， finally。 但是这其中是有一些地方不是特别明白，特记录于此。

try未发生异常时执行顺序

第1个情况：finally中无return

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class TryTest {

    public static void main(String[] args) {
        String result = testFunc();
        System.out.println(result);
    }

    private static String testFunc() {
        try {
            System.out.println("try executing");
            int result = 1 / 1;
            return "try end";
        } catch (Exception e) {
            System.out.println("catch executing");
            return "catch end";
        } finally {
            System.out.println("finally executing");
        }
    }
}

打印结果

try executing
finally executing
try end

第2个情况：finally中有return

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class TryTest {

    public static void main(String[] args) {

        String result = testFunc();
        System.out.println(result);
    }

    private static String testFunc() {
        try {
            System.out.println("try executing");
            int result = 1 / 1;
            return "try end";
        } catch (Exception e) {
            System.out.println("catch executing");
            return "catch end";
        } finally {
            System.out.println("finally executing");
            return "finally end";
        }
    }
}

打印结果

try executing
finally executing
finally end

所以总结上述两个情况：

  1. 当try无异常时，先执行try不经过catch然后再执行finally
  2. 若finally有return，则执行finally的return，程序结束 - (不推荐finally中使用return)
  3. 若finally无return，则执行try中的return，程序结束。

try中发生异常时执行顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class TryTest {

    public static void main(String[] args) {
        String result = testFunc();
        System.out.println(result);
    }
    private static String testFunc() {
        try {
            System.out.println("try executing");
            int result = 1 / 0;
            return "try end";
        } catch (Exception e) {
            System.out.println("catch executing");
            return "catch end";
        } finally {
            System.out.println("finally executing");
        }
    }
}

打印结果

try executing
catch executing
finally executing
catch end

总结：

  1. 先执行try，若有异常则进入catch，catch return前会先执行finally
  2. 若finally有return， 执行finally的return，程序结束 - 程序未贴出，参考try那一节
  3. 若finally无return，执行catch中的return，程序结束

三者的关系

  1. 编写顺序必定是try -> catch… -> finally
  2. 三者允许无catch或者无finally
  3. catch允许有多个
  4. 若catch分支未捕捉到实际抛出的异常，则往上层抛出
  5. 若存在finally语句分支，则finally必定会被执行