try...catch...finally代码块和return

最新推荐文章于 2024-05-09 19:57:03 发布
最新推荐文章于 2024-05-09 19:57:03 发布
阅读量1.8k 收藏 9
点赞数 1
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39685982/article/details/130366569
版权

return的位置\允许return出现的位置（能否同时出现）

return

return

return

catch

√

√

finally

√

finally后

√

1.finally块在return语句执行之后，return语句返回之前执行

2.finally块中的return语句返回结果会覆盖try块的return语句返回结果

        即如果try中有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）

3.finally块中的return语句返回结果会覆盖catch块中的return语句返回结果

        即如果try中有return语句，catch中也有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）

        try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句 

4.try块中发生异常，try块中异常语句后的内容不会执行（return语句自然不会执行），执行的是捕获到异常的catch语句块和finally语句块

5.如果finally块没有return语句，那么原来的返回值因为finally里的修改可能改变也有可能不变

        对于基本数据类型来说，finally中对返回值的修改不会影响try中return返回变量的值（解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）

        对于引用数据类型来说，finally中对返回值的修改（修改引用变量指向对象中的值）会影响try中return返回变量的值

        对于引用数据类型来说，finally中对返回值的修改（修改引用变量的地址值）不会影响try中return返回变量的值（解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）

6.try中发生异常时，return语句写在catch块中

        try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句

        对于基本数据类型来说，finally中对返回值的修改不会影响try中return返回变量的值（解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）

        对于引用数据类型来说，finally中对返回值的修改（修改引用变量指向对象中的值）会影响try中return返回变量的值

        对于引用数据类型来说，finally中对返回值的修改（修改引用变量的地址值）不会影响try中return返回变量的值（解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）

7.finally语句一定会被执行吗？

        当程序进入try语句之前就出现异常时，会直接结束

        try语句块中有强制退出时也不会执行finally语句块中的代码

package com.atdc.finallyAndReturn;

/*
 * @Author: guozhenran
 * @Date: 2023/4/25 10:07
 * @Description: finally块在return语句执行之后，return语句返回之前执行
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func() {
        int a = 10;
        try {
            System.out.println("try中的代码块");
            a += 10;
            return a;
        } catch (Exception e) {
            System.out.println("catch中的代码块");
        } finally {
            System.out.println("finally中的代码块");
            a += 10;
            if (a > 10) {
                System.out.println("a > 10," + "a=" + a);
            }
            a += 10;
        }
        System.out.println("haha");//如果catch中添加了【return a += 1000;】，这里会报错：Unreachable statement
        return a;
    }
}

 

package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:23
 * @Description: finally块中的return语句返回结果会覆盖try块的return语句返回结果
 *      即如果try中有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）
 */
public class Demo02_1 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func(){
        int a = 10;
        try{
            System.out.println("try中的代码块");
            a += 10;
            return a;
        }catch (Exception e){
            System.out.println("catch中的代码块");
        }finally {
            System.out.println("finally中的代码块");
            a += 10;
            if(a > 10){
                System.out.println("a>10," + "a=" + a);
            }
            a += 10;
            return a;
        }
    }
}
package com.atdc.finallyAndReturn;
import java.util.HashMap;
import java.util.Map;
/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:31
 * @Description: finally块中的return语句返回结果会覆盖try块的return语句返回结果
 *  *      即如果try中有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）
 */
public class Demo02_2 {
    public static void main(String[] args) {
        System.out.println(getMap());
    }

    public static Map<String,String> getMap(){
        Map<String,String> map = new HashMap<>();
        map.put("KEY","INIT");
        try{
            map.put("KEY","try");
            return map;
        }catch (Exception e){
            e.printStackTrace();
            map.put("KEY","catch");
        }finally {
            map.put("KEY","finally");
            map = null;
            return map;
        }
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:46
 * @Description: finally块中的return语句返回结果会覆盖catch块中的return语句返回结果
 *       即如果try中有return语句，catch中也有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）
 *
 *      try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句
 *      对于基本数据类型来说，finally中对返回值的修改不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
public class Demo03_1 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func(){
        int a = 10;
        try{
            System.out.println("try中的代码块");
            a = a /0;
            a += 10;
            return a ;
        }catch (Exception e){
            System.out.println("catch中的代码块");
            a += 10;
            return a;
        }finally {
            System.out.println("finally中的代码块");
            a += 10;
            if (a > 10){
                System.out.println("a > 10, a = "+a);
            }
            a += 10;
            return a;
        }
//        System.out.println("hahaha");//报错，Unreachable statement
//        return a += 10000;报错，Unreachable statement
    }
}
package com.atdc.finallyAndReturn;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:51
 * @Description: finally块中的return语句返回结果会覆盖catch块中的return语句返回结果
 *        即如果try中有return语句，catch中也有return语句，finally中也有return语句，最终执行的是finally中的return语句（无论是基本数据类型or引用数据类型）
 *
 *      try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量指向对象中的值）会影响try中return返回变量的值
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量的地址值）不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
public class Demo03_2 {
    public static void main(String[] args) {
        System.out.println(getMap());
    }

    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<>();
        map.put("KEY", "INIT");
        try {
            map.put("KEY", "try");
            String s = null;
            System.out.println(s.charAt(0));
            return map;
        } catch (Exception e) {
            e.printStackTrace();
            map.put("KEY", "catch");
            return map;
        } finally {
            map.put("KEY", "finally");
            map.remove("KEY");
            map.put("KEY", "finally2");
            map = null;
            System.out.println(map);
            return map;
        }
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:28
 * @Description: 如果finally块没有return语句，那么原来的返回值因为finally里的修改可能改变也有可能不变
 *      对于基本数据类型来说，finally中对返回值的修改不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
public class Demo04_1 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func(){
        int a = 10;
        try{
            System.out.println("try中的代码块");
            a += 10;
            return a;
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("catch中的代码块");
        }finally {
            System.out.println("finally中的代码块");
            a += 10;
            if(a > 10){
                System.out.println("a > 10,a="+a);
            }
            a += 10;
        }
        return a;
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:31
 * @Description: 如果finally块没有return语句，那么原来的返回值因为finally里的修改可能改变也有可能不变
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量指向对象中的值）会影响try中return返回变量的值
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量的地址值）不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
import java.util.HashMap;
import java.util.Map;

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

    public static Map<String,String> getMap(){
        Map<String,String> map = new HashMap<>();
        map.put("KEY","INIT");
        try{
            map.put("KEY","try");
            return map;
        }catch (Exception e){
            e.printStackTrace();
            map.put("KEY","catch");
        }finally {
            map.put("KEY","finally");
            map = null;
        }
        map.put("KEY", "hahaha");
        return map;
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:43
 * @Description: try块中发生异常，try块中异常语句后的内容不会执行（return语句自然不会执行），执行的是捕获到异常的catch语句块和finally语句块
 */
public class Demo05 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func() {
        int a = 10;
        try {
            System.out.println("try中的代码块");
            a = a / 0;
            a += 10;
            return a;
        } catch (Exception e) {
            a += 10;
            System.out.println("catch中的代码块");
        } finally {
            System.out.println("finally中的代码块");
            a += 10;
            if (a > 20) {
                System.out.println("a > 20,a =" + a);
            }
            a += 10;
        }
        System.out.println("hahaha");
        return a;
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:46
 * @Description: try中发生异常时，return语句写在catch块中
 *      try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句
 *      对于基本数据类型来说，finally中对返回值的修改不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
public class Demo06_1 {
    public static void main(String[] args) {
        System.out.println(func());
    }

    public static int func(){
        int a = 10;
        try{
            System.out.println("try中的代码块");
            a = a /0;
            a += 10;
            return a ;
        }catch (Exception e){
            System.out.println("catch中的代码块");
            a += 10;
            return a;
        }finally {
            System.out.println("finally中的代码块");
            a += 10;
            if (a > 10){
                System.out.println("a > 10, a = "+a);
            }
            a += 10;
        }
//        System.out.println("hahaha");//报错，Unreachable statement
//        return a += 10000;报错，Unreachable statement
    }
}
package com.atdc.finallyAndReturn;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:51
 * @Description: try中发生异常时，return写在catch语句中
 *      try中发生异常之后，进入catch块，return语句执行完之后进入finally块，finally块执行完之后，执行return返回语句
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量指向对象中的值）会影响try中return返回变量的值
 *      对于引用数据类型来说，finally中对返回值的修改（修改引用变量的地址值）不会影响try中return返回变量的值
 *      （解释：try或catch中的return要返回的值在finally执行之前会拷贝一份）
 */
public class Demo06_2 {
    public static void main(String[] args) {
        System.out.println(getMap());
    }

    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<>();
        map.put("KEY", "INIT");
        try {
            map.put("KEY", "try");
            String s = null;
            System.out.println(s.charAt(0));
            return map;
        } catch (Exception e) {
            e.printStackTrace();
            map.put("KEY", "catch");
            return map;
        } finally {
            map.put("KEY", "finally");
            map.remove("KEY");
            map.put("KEY", "finally2");
            map = null;
            System.out.println(map);
        }
    }
}
package com.atdc.finallyAndReturn;

/**
 * @Author: guozhenran
 * @Date: 2023/4/25 10:49
 * @Description: finally语句一定会被执行吗？
 *      当程序进入try语句之前就出现异常时，会直接结束
 *      try语句块中有强制退出时也不会执行finally语句块中的代码
 */
public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        try{
            System.out.println("try block");
            System.exit(0);
        }catch (Exception e){
            System.out.println("catch block");
        }finally {
            System.out.println("finally block");
        }
    }
}

参考：

finally语句与return语句详解_finally return_星光_依旧灿烂的博客-CSDN博客

finally 与 return - Hello_xzy_World - 博客园

不想当秃头冠军
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
trycatch.zip
07-18
总之，"trycatch.zip"中的示例展示了如何在Golang中模仿`try...catch`和`try...catch...finally`结构，通过自定义的函数和闭包实现了异常处理功能，这对于编写需要优雅处理错误的Golang代码来说非常有用。
try、catch、finally、return 执行顺序.doc
09-09
下面我们来详细讲解 try、catch、finally、return 执行顺序的规则和特点。 首先，我们需要了解 try、catch、finally 语句的基本用法。try 语句用于包装可能抛出异常的代码，catch 语句用于捕捉 try 语句中的异常，...
Java中finally与return的执行顺序
骏马逸动，心随你动的博客
03-24 8154
在Java的异常处理中，try、catch 和 finally 是按顺序执行的。如果 try 中没有异常，则顺序为 try→finally，如果 try 中有异常，则顺序为 try→catch→finally。但是当 try、catch、finally 中加入 return 之后，return 和 finally 的执行顺序让很多人混淆不清。下面来分别说明一下。 1. try 和 catch 中带有return 1）try 中带有 return public class tryDemo { ...
try里有return，finally还执行么？
m0_56020102的博客
11-27 2571
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的 值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数 返回值是在finally执行前确定的；4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。2、当try和catch中有return时，finally仍然会执行；执行，并且finally的执行早于try里面的return。
try-catch语句捕获异常后是否执行后续代码？
最新发布
2302_79960666的博客
05-09 770
在Java中，当异常被catch块成功捕获后，程序会执行catch块中的代码来处理异常。一旦catch块中的代码执行完毕，并且catch块内没有再次抛出新的异常或者程序没有退出（如System.exit(0)），那么程序会继续执行catch块之后的代码。这意味着catch块之后的代码段是有机会被执行的。
try-catch finally return 执行顺序
lxw1844912514的博客
02-02 601
如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的。有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。无异常：则再执行finally块，因为finally块中有return所以提前退出。再执行finally块，最后执行try中return;
try catch finally和return的执行顺序
一个人的Code博客
10-19 616
程序先执行try，如果遇到异常执行catch块， 有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行catch块中return. finally之后也就是4处的代码不再执行。最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的。
JavaScript 语句执行机制涉及的一种基础类型：Completion 类型
liuhua_2323的博客
11-04 1117
我们来看一个例子。在函数 foo 中，使用了一组 try 语句。我们可以先来做一个小实验，在 try 中有 return 语句，finally 中的内容还会执行吗？我们来看一段代码。 function foo(){ try{ return 0; } catch(err) { } finally { console.log("a") } } console.l...
C#笔试题 (2).pdf
02-27
10. .NET 错误处理：.NET 使用异常处理机制，通过`try-catch-finally`语句块捕获和处理异常，提供了一种结构化的方式来处理运行时错误。 11. 接口与类：接口定义了一组方法签名，而类则可以包含方法实现。类可以...
try-catch-finally-return-in-finally.rar_return
09-21
在这个例子中，尽管 `try` 和 `catch` 都有 `return`，但最终的返回值由 `finally` 块的 `return` 决定。`finally` 块总是会被执行，即使在 `try` 或 `catch` 中已经有一个 `return` 语句，这使得我们可以确保无论...
C#中的try catch finally用法分析
09-04
即使在`try`或`catch`块中有`return`语句，`finally`块的代码也会被执行。 ```csharp finally { // 无论是否发生异常都会执行的代码 } ``` 在示例中，无论`j`的值是否为0，`finally`块的`Console.WriteLine(j....
try catch finally 与return 的问题
whp404的博客
05-22 133
今天遇到一个有趣问题，就是关于 try 、catch 、finally 和 return的顺序问题，本来觉得自己理解的不错，但是结果还是大跌眼镜，特意记录一下 本文参考了 https://www.jianshu.com/p/06755f52ba90，感谢原作者 try里有return，finally怎么执行 finally块里的代码是在return之前执行的 public class Test...
try/finally的return问题
学习笔记。
05-16 248
如果try和finally里都有return，则以finally中的为主。 如果try里有return，finally里没有，但是finally能影响到try的返回结果，那么就用一个临时的值存储return结果避免受到finally里操作的影响。
Java：简述try-catch-finally中return返回
mingyuli的博客
03-15 976
java中的 finally关键字通常与 try/catch块一起使用。用来在方法结束前或发生异常时做一些资源释放的操作。虽然看起来很简单，在日常开发中也发现关于 finllay还是有些需要注意的地方。 一 . finally 语句块一定会执行吗？ 很多人都认为 finally语句块是肯定要执行的，比如下面的代码，只要进入了 try/catch块，不管有没有异常，都会执行 finllay块。 public static void main(String[] args) { System...
Java：当try与finally中都出现return的处理逻辑
stone1146753110的博客
01-05 486
java语法
JavaSE之彻底搞懂try,catch,finally与return的执行
piaoxuan1987
03-04 572
在开始我的博客之前，我先引用马士兵老师的一句话，掌握了内存你就掌握了一切（滑稽）。 一般情况下，程序执行到try里面的内容一定会执行finally里面的内容。如果在try或者catch里面遇到return，那么函数在执行完return后面的表达式之后，会先去执行finally里面的语句块，然后再结束方法体。但有一种特殊情况，如果在try里面有System.exit(0)这样的语句，Sys...
return在finally前执行还是后执行？
weixin_52222660的博客
05-18 1353
如果在finally前面有return，那么也会先把finally中的代码执行完，再执行return，所以。当程序执行到return的时候，会结束这个方法，并且会把return后面的值，返回到方法调用的地方。finally是用在异常处理中，放在catch之后，finally中的代码是一定会执行的。
【Java基础面试四十】、在finally中return会发生什么？
做笔记\记录遇到的程序bug
10-22 189
当Java程序执行try块、catch块时遇到了return或throw语句，这两个语句都会导致该方法立即结束，但是系统执行这两个语句并不会结束该方法，而是去寻找该异常处理流程中是否包含finally块，如果没有finally块，程序立即执行return或throw语句，方法终止；在通常情况下，不要在finally块中使用return、throw等导致方法终止的语句，一旦在finally块中使用了return、throw语句，将会导致try块、catch块中的return、throw语句失效。
JAVA面试，try、catch、finally带return的执行顺序总结Demo案例
dear_Alice_moon的专栏
01-13 236
JAVA面试，try、catch、finally带return的执行顺序总结Demo案例
try..catch里面有return语句,finally里面的语句还会执行吗?
09-08
在try...catch语句中，如果try块中的代码出现了异常，catch块会捕获这个异常并执行相应的处理逻辑。在catch块中，如果有return语句，那么这个return语句将会立即结束方法的执行，并将返回值返回给调用方。 在try...catch...finally语句中，finally块中的语句无论try块中是否出现异常，都会被执行。即使try块中有return语句，finally块中的语句也会执行。当遇到return语句时，会先执行finally块中的代码，然后才会返回到调用方。 需要注意的是，如果finally块中也有return语句，那么不管try块中是否出现异常，finally块中的return语句都会将结果返回给调用方，而try或catch块中的return语句将被忽略。 总结起来，无论try块中是否出现异常，catch块中是否有return语句，finally块中的代码都会执行。而如果finally块中有return语句，它将覆盖try或catch块中的return语句，成为最终的返回结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值