java try catch finally执行顺序总结

最新推荐文章于 2023-12-22 19:30:26 发布
最新推荐文章于 2023-12-22 19:30:26 发布
阅读量519 收藏 2
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xushiyu1996818/article/details/106551808
版权
本文深入探讨Java中try、catch、finally语句对返回值的影响，解析不同场景下返回值的执行顺序，以及异常抛出与处理机制。通过具体代码示例，详细阐述了finally块如何在try或catch中的return语句执行后、返回前运行，以及其对返回值的可能影响。
摘要由CSDN通过智能技术生成

目录

返回值的执行顺序

try内return，finally不做特殊动作

try内return，finally也return

try内return，finally对之前return的内容进行修改

try内return之前出现异常，finally和catch对变量作修改

try内出现异常，catch内return，finally进行各种动作 

return总结

抛出异常

catch中抛出异常，finally不做特殊动作

catch中抛出异常，finally return

catch中抛出异常，finally 也抛出异常

catch中抛出异常，finally 试图捕获catch的异常

catch内抛出异常总结

返回值的执行顺序

try内return，finally不做特殊动作

public class FinallyTest1 {

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

    public static int test1() {
        int b = 20;

        try {
            System.out.println("try block");

            return b += 80; 
        }
        catch (Exception e) {

            System.out.println("catch block");
        }
        finally {
            
            System.out.println("finally block");
            
            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }
        }
        
        return b;
    }
    
}

运行结果是：

try block
finally block
b>25, b = 100
100

说明try里的return语句已经执行了，再去执行finally语句，不过并没有直接返回，而是等finally语句执行完了再返回结果。

如果觉得这个例子还不足以说明这个情况的话，下面再加个例子加强证明结论：

public class FinallyTest1 {

    public static void main(String[] args) {
        
        System.out.println(test11());
    }
    
    public static String test11() {
        try {
            System.out.println("try block");

           return test12();
      } finally {
           System.out.println("finally block");
       }
  }

  public static String test12() {
       System.out.println("return statement");

       return "after return";
   }
    
}

运行结果为：

try block
return statement
finally block
after return

说明try中的return语句先执行了但并没有立即返回，先保存了after return 这个字符串，等到finally执行结束后再返回这个字符串，让main程序打印

这里大家可能会想：如果finally里也有return语句，那么是不是就直接返回了，try中的return就不能返回了？看下面。

 

try内return，finally也return

public class FinallyTest2 {

    public static void main(String[] args) {

        System.out.println(test2());
    }

    public static int test2() {
        int b = 20;

        try {
            System.out.println("try block");

            return b += 80;
        } catch (Exception e) {

            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            return 200;
        }

        // return b;
    }

}

运行结果是：

try block
finally block
b>25, b = 100
200

这说明finally里的return直接返回了，就不管try中是否还有返回语句，这里还有个小细节需要注意，finally里加上return过后，finally外面的return b就变成不可到达语句了，也就是永远不能被执行到，所以需要注释掉否则编译器报错。

这里大家可能又想：如果finally里没有return语句，但修改了b的值，那么try中return返回的是修改后的值还是原值？看下面。

try内return，finally对之前return的内容进行修改

public class FinallyTest3 {

    public static void main(String[] args) {

        System.out.println(test3());
    }

    public static int test3() {
        int b = 20;

        try {
            System.out.println("try block");

            return b += 80;
        } catch (Exception e) {

            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            b = 150;
        }

        return 2000;
    }

}

运行结果是：

try block
finally block
b>25, b = 100
100

相当于try 里面return  100时，将100这个值存起来了，而且不是存了b这个变量，所以对finally的修改无效，同时finally结束了，就直接返回100，没有执行return 2000

import java.util.*;

public class FinallyTest6
{
    public static void main(String[] args) {
        System.out.println(getMap().get("KEY").toString());
    }
     
    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("KEY", "INIT");
         
        try {
            map.put("KEY", "TRY");
            return map;
        }
        catch (Exception e) {
            map.put("KEY", "CATCH");
        }
        finally {
            map.put("KEY", "FINALLY");
            map = null;
        }
         
        return map;
    }
}

运行结果是：

FINALLY

相当于try 里面return  map时，将map这个变量的地址存起来了，而且不是存了map这个变量，所以对finally的修改了map这个变量对应的对象的内容，map为null修改了map的地址，但无效，因为地址已经存起来了

为什么测试用例1中finally里的b = 150;并没有起到作用，而测试用例2中finally的map.put("KEY", "FINALLY");起了作用，而map = null;却没起作用呢？

这就是Java到底是传值还是传址的问题了，简单来说就是：Java中只有传值没有传址，这也是为什么map = null这句不起作用。

这同时也说明了返回语句是try中的return语句而不是 finally外面的return b;这句

不相信的话可以试下，将return b;改为return 294，对原来的结果没有一点影响。

这里大家可能又要想：是不是每次返回的一定是try中的return语句呢？那么finally外的return b不是一点作用没吗？请看下面。

try内return之前出现异常，finally和catch对变量作修改

public class FinallyTest4 {

    public static void main(String[] args) {

        System.out.println(test4());
    }

    public static int test4() {
        int b = 20;

        try {
            System.out.println("try block");

            b = b / 0;

            return b += 80;
        } catch (Exception e) {

            b += 15;
            System.out.println("catch block");
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            b += 50;
        }

        return b;
    }

}

运行结果是：

try block
catch block
finally block
b>25, b = 35
85

这里因 为在return之前发生了除0异常，所以try中的return不会被执行到，而是接着执行捕获异常的catch 语句和最终的finally语句，此时两者对b的修改都影响了最终的返回值，这时return b;就起到作用了。

当然如果你这里将return b改为return 300什么的，最后返回的就是300，这毋庸置疑。

这里大家可能又有疑问：如果catch中有return语句呢？当然只有在异常的情况下才有可能会执行，那么是在finally之前就返回吗？看下面。

try内出现异常，catch内return，finally进行各种动作 

public class FinallyTest5 {

    public static void main(String[] args) {

        System.out.println(test5());
    }

    public static int test5() {
        int b = 20;

        try {
            System.out.println("try block");
            
            b = b /0;

            return b += 80;
        } catch (Exception e) {

            System.out.println("catch block");
            return b += 15;
        } finally {

            System.out.println("finally block");

            if (b > 25) {
                System.out.println("b>25, b = " + b);
            }

            b += 50;
        }

        //return b;
    }

}

运行结果如下：

try block
catch block
finally block
b>25, b = 35
35

说明了发生异常后，catch中的return语句先执行，确定了返回值后再去执行finally块，执行完了catch再返回，finally里对b的改变对返回值无影响，原因同前面一样，也就是说情况与try中的return语句执行完全一样。

如果b=b+50后，再去return b，才会对try和catch里面返回的b的值进行修改。

return总结

最后总结：finally块的语句在try或catch中的return语句执行之后，返回之前执行。

且finally里的修改语句可能影响也可能不影响try或catch中 return已经确定的返回值（数值不影响，引用影响），若finally里也有return语句则覆盖try或catch中的return语句，直接返回。

抛出异常

catch中抛出异常，finally不做特殊动作

	public static void main(String[] args) {

		System.out.println(test());
	}

	public static String test() {
		try {
			System.out.println("try block");
			int a = 1 / 0;
			return "try result";
		} catch (Exception e) {
			System.out.println("catch block");
			int b = 1 / 0;
			return "catch result";

		} finally {
			System.out.println("finally block");
			//return "finally result";
		}
	}

catch抛出异常后，finally继续执行，保留抛出的异常b，然后继续抛出

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at test.t05new.Test9.test(Test9.java:27)
    at test.t05new.Test9.main(Test9.java:17)
try block
catch block
finally block

catch中抛出异常，finally return

	public static String test() {
		try {
			System.out.println("try block");
			int a = 1 / 0;
			return "try result";
		} catch (Exception e) {
			System.out.println("catch block");
			int b = 1 / 0;
			return "catch result";

		} finally {
			System.out.println("finally block");
			return "finally result";
		}
	}

try block
catch block
finally block
finally result

return清除了catch里面抛出的异常

catch中抛出异常，finally 也抛出异常

	public static void main(String[] args) {

		System.out.println(test());
	}

	public static String test() {
		try {
			System.out.println("try block");
			int a = 1 / 0;
			return "try result";
		} catch (Exception e) {
			System.out.println("catch block");
			int b = 1 / 0;
			return "catch result";

		} finally {
			System.out.println("finally block");
			int c = 1 / 0;
			return "finally result";
		}
	}

try block
catch block
finally block
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at test.t05new.Test9.test(Test9.java:32)
    at test.t05new.Test9.main(Test9.java:17)

finally抛出的异常替代了catch抛出的异常

 

catch中抛出异常，finally 试图捕获catch的异常

	public static void main(String[] args) {

		System.out.println(test());
	}

	public static String test() {
		try {
			System.out.println("try block");
			int a = 1 / 0;
			return "try result";
		} catch (Exception e) {
			System.out.println("catch block");
			int b = 1 / 0;
			return "catch result";

		} finally {			
			System.out.println("finally block");
			try {
				System.out.println("finally block2");
			} catch (Exception e2) {
				System.out.println("finally block3");
				return "finally result";
			}
			//int c = 1 / 0;
			//return "finally result";
		}
	}

try block
catch block
finally block
finally block2
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at test.t05new.Test9.test(Test9.java:27)
    at test.t05new.Test9.main(Test9.java:17)

可以看到没有捕获到异常b，异常b被程序保留了，没有传递给finally

catch内抛出异常总结

catch内抛出异常，catch内流程被中断，程序内保存了这个异常，然后finally正常执行，如果内部return或者抛出异常，终止程序，然后return或者finally内异常覆盖了catch的异常。

xushiyu1996818
关注
专栏目录
Java异常处理--异常处理的方式1：try-catch-finally
人生得意须尽欢
01-12 1357
Java异常处理--异常处理的方式1：try-catch-finally
java try…catch…finally捕获异常的实例
06-18
java try…catch…finally捕获异常的实例 java try…catch…finally捕获异常的实例
【Java笔记】try/catch/finally执行顺序及总结（含return）
长路漫漫的歇脚处
11-28 1291
一、try/catch/finally在没有return的情况下 无异常：try->finally->跳出 有异常：try->catch->finally->跳出 二、try/catch/finally在含有return的情况下 大致存在六种情况： 1、情况1：try{} catch(){}finally{} return; 结果显然是程序按顺...
java面试知识点：try catch finally 执行顺序
Brave Soul Blog
04-18 560
java面试知识点：try catch finally 执行顺序 有return的情况下try catch finally的执行顺序 结论： 不管有没有出现异常，finally块中代码都会执行； 当try和catch中有return时，finally仍然会执行； finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代...
try、catch、finally的执行顺序
xingyu19911016的博客
09-26 9086
1. 不带return的执行顺序 异常处理中，try、catch、finally的执行顺序： 如果try中没有异常，执行顺序为：try->finally 如果try中有异常，执行顺序为：try->catch->finally public class Test { public static int rank; public static void main(String[] args) { rank = 1; solve2(); System.ou
JAVA中try catch finally执行顺序
WannaRunning的博客
01-31 431
1、try-catch-finally执行顺序： 一、执行try{}块； 二、如果try{}块有异常产生，执行catch{}块； 三、无论有没有异常都要执行finally{}块，这里可以看出只要finally中有return，必然返回finally{}中的return。 如： try{   语句1；   语句2；   语句3； }catch(){   语句4；
Java try catch finally异常处理组合详解
08-19
Java try catch finally异常处理组合详解 Java try catch finally异常处理组합是Java语言中的异常处理机制，用于捕获和处理程序中的异常。下面对try catch finally异常处理组合进行详细的介绍。 try catch组合： ...
try catch finally的执行顺序深入分析
09-05
在这个过程中，函数会将`try`或`catch`块中的`return`语句返回的值暂存起来，然后执行`finally`块。 如果在`finally`块中也有`return`语句，那么这个`return`值会覆盖之前暂存的值。也就是说，最终返回给调用者的值...
try-catch-finally执行顺序验证
01-20
try-catch-finally执行顺序验证(左边是.java文件，右边是.class文件) 提示： try、catch块内的return操作编译后会变成把return的值保存到变量var的操作。 总结: try、catch块内的return操作编译后会变成把return的值...
Java关于Try-Catch-Finally的执行顺序和Return值问题总结
yuncaidaishu的博客
08-23 371
一：执行顺序问题 1.当三个代码块都有代码时： （1）首先执行Try代码块，如果Try代码块顺利执行，就直接执行Finally代码块。 （2）首先执行Try代码块，如果Try代码块发生异常，就会执行Catch代码块，最后执行Finally代码块。 2.当只有Try和Finally代码块时： （1）首先执行Try代码块，如果Try代码块顺利执行，就直接执行Finally代码块。 ...
java中 try、catch、finally 执行顺序
希望有志同道合的的朋友可以互相学习！
12-15 245
在Java程序中，异常处理是重要技术，当处理块中包含return语句时
JAVA try catch finally return 执行顺序
X-Dragon的博客
11-11 1395
JAVA try catch finally return 执行顺序 参考:https://www.cnblogs.com/superFish2016/p/6687549.html 一、结论 1、不管有没有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、如果try、catch中有return语句，finally是在return...
Java异常机制--try catch finally 执行顺序详解
qq_35392674的博客
03-31 184
https://blog.csdn.net/u013309870/article/details/73498860
Java try catch finally的顺序问题
talenthua的博客
09-07 102
1.结论 正确顺序：try-catch-finally 错误顺序： try-finally-catch 等 2.示例代码 2.1正确顺序，编译正常，执行结果正常。 package huafeng2019.github.io804; public class Main { public static void main(String[] args) { try { Object obj = null; System.out.p...
Java try、catch、finally执行顺序
weixin_43914164的博客
08-09 2238
Java中，try块，catch块，finally块的常见执行顺序分为有异常和无异常。无异常：try->finally；有异常：try->catch->finally。根据这两种情况，跑一遍无返回值和有返回值的具体执行变化 创建一个测试类，编写异常捕获的测试函数 在项目pom文件中添加测试类依赖 <dependency> <groupId>org.springframework.boot</groupId> <ar
try、catch、finally 语句块的执行顺序。
最新发布
NZC2237的博客
12-22 812
try 块中的代码首先执行，然后根据情况执行相匹配的 catch 块（如果有异常抛出），最后执行 finally 块。即使在 try 或 catch 块中有 return 语句，finally 块依然会在方法返回之前执行。
Java中try，catch，finally执行顺序
Humphrey0313
12-22 4129
Java中try，catch，finally代码执行顺序是怎么样的？如果带有return又是怎样的？这是面试常考的一个问题。 先给出结论： 1.如果try中没有异常，则顺序为try→finally；如果try中有异常，顺序为try→catch→finally，并且异常之后的代码不会执行。 2.当try或catch中带有return时，会先执行return前的代码，然后暂时保存需要return的信息，再执行finally中的代码，最后再通过return返回之前保存的信息。 还要注意，如果return的
try,catch,finally执行顺序分析
nn1__2970的博客
02-14 2640
try…catch…finally
【Java基础】try-catch-finally执行流程
YHALcong的博客
02-13 1329
一、函数完全由try-catch-finally构成 public void tryCatch{ try { //try statement 1 //try statement 2 } catch(ArithmeticException ex) { //catch ArithmeticException ...
try catch finally 执行顺序
04-26
在 Java 中，try catch finally 块的执行顺序如下： 1. 首先执行 try 块中的代码； 2. 如果在 try 块中没有出现任何异常，则跳过 catch 块，并执行 finally 块中的代码； 3. 如果在 try 块中出现了异常，则会跳过 try 块中剩余的代码，并执行与所抛出异常类型相符的 catch 块中的代码； 4. 无论是否出现异常，finally 块中的代码总是会被执行。 注意：如果 try 块中抛出异常后，没有相对应的 catch 块，则程序会崩溃并输出异常信息。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值