【JAVA基础】try catch finally用法_java try catch finally用法-CSDN博客

本文链接：https://blog.csdn.net/lp15929801907/article/details/108590345

本文详细解析了Java中try...catch...finally结构的执行顺序及return语句的影响，通过多个实例阐述了不同场景下变量a的最终值，帮助理解异常处理机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

try…catch…finally…用法（执行顺序）

在java中，有两种异常处理方式，一种是直接抛出函数（throws Exception），另外一种是直接在函数内部进行处理（try catch finally）。但是在 try…catch…finally…结构中，程序执行顺序是怎样的呢？

一、都没有 return 的情况

package CSDN;
public class Test1 {
    public static void main(String[] args) {
    System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a = 10;
            //a=a/0;
        } catch (Exception e) {
            a = 20;
        } finally {
            a = 30;
        }
        return a;
    }
}
//a=30

执行顺序：先执行try块，10赋值给了a，如果有异常抛出，则执行catch块，20赋值给了a，catch块执行完毕后，执行finally块，30赋值给了a；如果没有异常抛出，跳过catch块，直接执行finally块，30赋值给了a。所以a的值是30。

二、只有try中有return的情况

package CSDN;
public class Test2 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            return a;
        } catch (Exception e) {
            a = 20;
        } finally {
            a = 30;
        }
        return a;
    }
}
//a=10

执行顺序：先执行try块，10赋值给了a，try中有return，返回10，即使在finally或catch中，修改了a的值，但是在执行finally或catch块之前，try中的return已经记录了要返回的10，finally或catch中没有return，修改了也没关系。所以a的值是10。

三、只有catch中有return的情况（出现异常）

package CSDN;
public class Test3 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            a=a/0;
        }catch (Exception e){
            a=20;
            return a;
        }finally {
            a=30;
        }
        return a;
    }
}
//a=20

执行顺序：先执行try块，出现了异常（0不能当作被除数），所以执行catch，20赋值给了a，catch中有return，返回20，继续执行finally块，30赋值给了a，虽然修改了a的值，但是finally块没有return，还是返回20。所以a的值是20。

当try块没有异常出现时，跳过catch块，执行finally块，30赋值给了a，虽然catch块中有return，但没有执行，所以返回30，a的值是30。

四、只有finally中有return的情况

package CSDN;
public class Test4 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            //a=a/0;
        }catch (Exception e){
            a=20;
        }finally {
            a=30;
            return a;
        }
    }
}
//a=30

执行顺序：先执行try块，10赋值给了a，如果有异常抛出，则执行catch块，20赋值给了a，catch块执行完毕后，执行finally块，30赋值给了a；如果没有异常抛出，跳过catch块，直接执行finally块，30赋值给了a，finally中有return，返回30。所以a的值是30。

五、try、catch中有return的情况(出现异常)

package CSDN;
public class Test5 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            return a=a/0;
        }catch (Exception e){
            a=20;
            return a;
        }finally {
            a=30;
        }
    }
}
//a=20

执行顺序：先执行try块，10赋值给了a，try中有return，return后面出现了异常（0不能当作被除数），所以执行catch，20赋值给了a，catch中有return，返回20，继续执行finally块，30赋值给了a，虽然修改了a的值，但是finally块没有return，还是返回20。所以a的值是20。

当try块没有异常出现时，跳过catch块，执行finally块，30赋值给了a，虽然修改了a的值，但是finally块没有return，而catch块中有return，没有执行，还是返回10。所以a的值是10。

六、try、finally中有return的情况

package CSDN;
public class Test6 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            return a;
        }catch (Exception e){
            a=20;
        }finally {
            a=30;
            return a;
        }
    }
}
//a=30

执行顺序：先执行try块，10赋值给了a，try中有return，返回10，没有异常抛出，跳过catch块，直接执行finally块，30赋值给了a，finally中有return，会忽略try中的return，返回30。所以a的值是30。

七、catch、finally中有return的情况（出现异常）

package CSDN;
public class Test7 {
    public static void main(String[] args) {
        System.out.print(test());
    }
    public static int test() {
        int a;
        try {
            a=10;
            a=a/0;
        }catch (Exception e){
            a=20;
            return a;
        }finally {
            a=30;
            return a;
        }
    }
}
//a=30

执行顺序：先执行try块，块中出现了异常（0不能当作被除数），所以执行catch，20赋值给了a，catch中有return，返回20，继续执行finally块，30赋值给了a，finally中有return，会忽略catch中的return，返回30。所以a的值是30。

当try块没有异常出现时，跳过catch块，执行finally块，30赋值给了a，finally块中有return，而catch块中有return，没有执行，返回30。所以a的值是还是30。

八、try、catch、finally中都有return的情况

package CSDN;
public class Test8 {
    public static void main(String[] args) {
        System.out.print(test4());
    }
    public static int test4() {
        int a;
        try {
            a=10;
            return a/0;
        }catch (Exception e){
            a=20;
            return a;
        }finally {
            a=30;
            return a;
        }
    }
}
//a=30

执行顺序：先执行try块，10赋值给了a，try中有return，return后面出现了异常（0不能当作被除数），所以执行catch，20赋值给了a，catch中有return，返回20，继续执行finally块，30赋值给了a，finally中有return，会直接忽略try、catch中的return，返回30。所以a的值是30。

九、总结

1、不管有没有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally中没有return，finally仍然会执行，但不会改变try、catch中返回的变量，因为函数返回值是在finally执行前确定的，finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值）。它应该使用栈保存返回值。
3、尽量不要在finally中使用return语句，如果使用的话，会忽略try、catch中的返回语句，也会忽略try、catch中的异常，屏蔽了错误的发生；
4、finally中要避免再次抛出异常，一旦finally中发生异常，代码执行将会抛出finally中的异常信息，try、catch中的异常将被忽略；
5、当finally中没有return时，try或者catch哪一个有return，都会先把这个值存起来，然后走finally，如果是基本数据类型，那么怎么修改，都不影响已经存起来的返回值，如果是引用类型那么就要注意，很可能会修改值；当finally有return时，直接忽略try、catch中的return，返回finally中的返回值。
6、try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行。return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。