我在进行逆向的时候就遇到了将加密代码放在try，catch函数中进行隐藏，所以出现了无法反编译的情况，所以其前来学习其基本原理

1.try-catch-finally执行顺序

1. try中出现异常跳转到catch
2. 若catch中出现异常则跳转到finall
3. try或catch正常执行若存在return则先执行return的代码并保存返回值信息（基本类型保存值信息，引用类型则保存地址信息下面会说明），然后执行finally
4. finally中出现异常或包含return则执行结束，若无异常且没有return则会执行try或catch中的return或结束

2.代码说明

1.try-catch-finally中无return

如果try块中出现异常则进入catch中，执行完catch中代码后进入finally

如果catch中出现异常仍然会执行finally代码块，finally块执行结束后抛出异常

try块中无异常时执行完try块直接执行finally

catch中抛出异常为例

public static int testNoReturn(){
        int res = 1;
        try{
            res++;
            System.out.println("try ======== res:"+res);
            int a = 1/0;
        }catch (Exception e){
            res++;
            System.out.println("catch ======== res:"+res)public static int testNoReturn() {
    int res = 1; // 初始化变量 res 为 1
    try {
        res++; // res 自增 1
        System.out.println("try ======== res:" + res);
        int a = 1/0; // 执行除法操作，引发异常
    } catch (Exception e) {
        res++; // res 自增 1
        System.out.println("catch ======== res:" + res);
        int a = 1/0; // 执行除法操作，引发异常
    } finally {
        res++; // res 自增1
        System.out.println("finally ======== res:" + res);
    }
​
    return res; // 返回 res 的最终值
}
            int a = 1/0;
        }finally {
            res++;
            System.out.println("finally ======== res:"+res);
        }
        return res;
    }
​

catch中抛出异常后finally仍然会执行，执行结束后抛出catch中的异常

2.try或catch中存在return

（inally中包含return时会覆盖try或catch中的return值，而且会覆盖catch中抛出的异常信息）

try或catch包含return

public static int testTryCatchReturn() {
        int res = 1; // 初始化变量 res 为 1
​
        try {
            res++; // res 自增 1
            System.out.println("try ======== res:" + res);
            int a = 1 / 0; // 执行除法操作，引发异常
            return res; // 在异常之后，尝试返回 res 的值
        } catch (Exception e) {
            res++; // res 自增 1
            System.out.println("catch ======== res:" + res);
            return res; // 在异常捕获后，返回 res 的值
        } finally {
            res++; // res 自增 1
            System.out.println("finally ======== res:" + res);
        }
}

结果如下

try或catch中存在return时会将返回值进行保存（基本数据类型直接保存，引用数据类型则保存引用地址），然后执行finally块中的代码，finally块中代码执行结束后直接返回

因为引用类型返回时保存的是地址，所以修改引用对象时返回信息会发生变化

如果赋值为null时地址指向的信息并未发生变化所以返回值依然是地址指向的对象。  

当finally中存在return时会覆盖try或catch中返回的数据

如果catch中抛出异常时会将该异常覆盖掉以catch中存在异常的情况

public static int testFinallyReturn() {
        int res = 1; // 初始化变量 res 为 1
​
        try {
            res++; // res 自增 1
            System.out.println("try ======== res:" + res);
            int a = 1 / 0; // 执行除法操作，引发异常
            return res; // 在异常之后，尝试返回 res 的值
        } catch (Exception e) {
            res++; // res 自增 1
            System.out.println("catch ======== res:" + res);
            int a = 1 / 0; // 再次执行除法操作，引发异常
            return res; // 在异常捕获后，返回 res 的值
        } finally {
            res++; // res 自增 1
            System.out.println("finally ======== res:" + res);
            return res; // 最终在finally块中返回 res 的值，覆盖之前的返回值
        }
}

finally的return会覆盖catch或try的return和异常信息

3.总结

1. 无return且未出现异常时try->finally，出现异常时try->catch->finally
2. try或catch中有return时，返回数据为基本类型则finally代码块执行完后不会更改，返回值为引用类型，return保存的是引用地址，finally块中代码执行完会改变返回值
3. finally中存在return时会覆盖try或catch中的返回值信息，若try或catch中抛出异常也会被finally中的return覆盖