try-catch-finally的执行顺序

╰+哭是因爲堅強的太久メ 2023-10-03 12:48 24阅读 0赞

### try-catch-finally的执行顺序 ###

**结论：**

1.  不管有没有出现异常，finally代码块都会执行；
2.  不管try和catch的代码块中有return时，finally仍会执行，且如果finally代码块也有return，则此代码肯定会返回finally执行的return值。

分有return和没有return来讨论try-catch-finally执行顺序的情况：

### 1 无return ###

举个例子：

try {
        
        t();
        tt();
    } catch (Exception e) {
        
        c();
    } finally {
        
        f();
    }
    m();

**1.1 当try中的t()没有抛出异常**  
因为没有捕捉到异常，那么执行try而不会执行catch，而finally无论如何都要执行。  
其执行顺序为：t() --> tt() --> f() --> m()

**1.2 当try中的t()抛出了异常**  
当 t() 中抛出异常，那么 t() 中从抛出异常的语句之后的代码以及 tt() 都不会执行， 程序会尝试捕捉异常。  
捕捉Exception，捕捉成功，执行 c() ；  
一旦捕捉到一个异常，不会再尝试捕捉其他异常，直接执行finally里的f();  
执行后面的函数 m() 。  
其执行顺序为：t() --> c() --> f() --> m()

### 2 有return ###

**2.1**

try{
        }
    catch(){
        }
    finally{
        }
    return;

程序按顺序执行

**2.2 try块中有return**

try{
        return 1;}
    catch(){
        }
    finally{
        }
    return 2;

程序执行try块中return之前（包括return语句中的表达式运算）代码；  
再执行finally块，最后执行try中return;  
finally块之后的语句return不再执行，因为程序在try中已经return过了。  
结论：得到try中的返回值1。

**2.3 catch块中有return**

try{
        }
    catch(){
        return 1;}
    finally{
        }
    return 2;

程序先执行try，如果遇到异常执行catch块，

*  有异常：执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行catch块中return。 finally之后的return不再执行。
 *  无异常：执行完try再finally再return。

结论：有异常影响catch，执行catch中的return得到返回值1。  
**2.4 try块和finally块中有return**

try{
        return 1;}
    catch(){
        }
    finally{
        return 2;}

*  无异常：程序执行try块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出，而不再执行try中的return；
 *  有异常：不执行try，顺序执行catch-finally

结论：得到finally中的返回值2。

**2.5 catch块和finally块中有return**

try{
        }
    catch(){
        return 1;}
    finally{
        return 2;}

*  无异常：执行try后跳过catch执行finally；得到finally的返回值2；
 *  有异常：程序执行catch块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出。而不再执行catch中的return。

结论：得到finally中的返回值2。

**2.6 try块、catch块和finally块中有return**

try{
        return 1;}
    catch(){
        return 2;}
    finally{
        return 3;}

程序执行try块中return之前（包括return语句中的表达式运算）代码；

*  无异常：然后再执行finally块，因为finally块中有return所以提前退出。
 *  有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出。  
    结论：得到finally中的返回值3。

**3 总结**  
无return，无异常

try ->finally

无return，有异常

try(未出现异常的前半段) -> catch ->finally

try或catch中有return，无异常

try -> finally ->return(try)

try或catch中有return，有异常

try(未出现异常的前半段) -> catch ->finally->return(catch)

只要是finally中有return的情况  
不论有没有异常,try或catch中有没有return

try/catch->return(finally)

我们可以看出当finally中有return的时候，相当于此代码肯定会返回该值。

**4. 补充**

public class ExceptionTest {
        
        int age;
        public static void main(String[] args) {
        
            System.out.println(test().age);
        }
        public static ExceptionTest test() {
        
            ExceptionTest test = new ExceptionTest();
            try {
        
                test.age = 10;
                return test;
            }catch (Exception e) {
        
                test.age = 20;
                return test;
            }finally {
        
                test = new ExceptionTest();
                test.age = 30;
            }
        }
    }

输出：10  
当 try-catch 块中有return 语句时，return 语句会暂存变量值，然后执行 finally 代码块。

**总结：**  
1、不管有没有出现异常，finally块中代码都会执行；  
2、当try和catch中有return时，finally仍然会执行；  
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；  
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。 最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。 如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的， 编译器把finally中的return实现为一个warning。