Java 中关于 try、catch、finally 中的细节分析和注意点

最新推荐文章于 2022-03-23 21:22:41 发布
最新推荐文章于 2022-03-23 21:22:41 发布
阅读量224 收藏
点赞数
分类专栏： java基础 java-web 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengTornado/article/details/105093665
版权 
   <!--单元测试3个-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.2.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

package com.ruoyi.web.controller.platform;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * Java 中关于 try、catch、finally 中的细节分析
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class TryCatchFinally {
    private final static Logger logger = LoggerFactory.getLogger(TryCatchFinally.class);


    public String test1() {
        String t = "";
        try {
            t = "try";
            return t;
        } catch (Exception e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
        }
    }

    /**
     * 首先程序执行try语句块,把变量t赋值为try，由于没有发现异常，
     * 接下来执行finally语句块，把变量t赋值为finally，然后return t，则t的值是finally，最后t的值就是finally，程序结果应该显示finally，
     * 但是实际结果为try。
     */
    @Test
    public void result1() {
        logger.info("=============test1返回结果：{}===============", test1());
    }


    public String test2() {
        String t = "";

        try {
            t = "try";
            return t;
        } catch (Exception e) {
            // result = "catch";
            t = "catch";
            return t;
        } finally {
            t = "finally";
            return t;
        }
    }

    /**
     * 我们发现try语句中的return语句给忽略。
     * 可能jvm认为一个方法里面有两个return语句并没有太大的意义，所以try中的return语句给忽略了，
     * 直接起作用的是finally中的return语句，所以这次返回的是finally。
     */
    @Test
    public void result2() {
        logger.info("=============test2返回结果：{}===============", test2());
    }

    public String test3() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (Exception e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
            logger.info("########finally的值是{}###########", t);

        }
    }

    /**
     * 这里面try语句里面会抛出 java.lang.NumberFormatException，所以程序会先执行catch语句中的逻辑，t赋值为catch，
     * 在执行return之前，会把返回值保存到一个临时变量里面t '，
     * 执行finally的逻辑，t赋值为finally，但是返回值和t'，
     * 所以变量t的值和返回值已经没有关系了，返回的是catch
     */
    @Test
    public void result3() {
        logger.info("=============test3返回结果：{}===============", test3());
    }

    public String test4() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (Exception e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
            return t;
        }
    }

    /**
     * 这个和test2有点类似，由于try语句里面抛出异常，程序转入catch语句块，
     * catch语句在执行return语句之前执行finally，
     * 而finally语句有return,则直接执行finally的语句值，返回finally
     */
    @Test
    public void result4() {
        logger.info("=============test4返回结果：{}===============", test4());
    }

    public String test5() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (Exception e) {
            t = "catch";
            Integer.parseInt(null);
            return t;
        } finally {
            t = "finally";
            //return t;
        }
    }

    /**
     * 这个例子在catch语句块添加了Integer.parser(null)语句，强制抛出了一个异常。
     * 然后finally语句块里面没有return语句。
     * 继续分析一下，由于try语句抛出异常，程序进入catch语句块，catch语句块又抛出一个异常，说明catch语句要退出，
     * 则执行finally语句块，对t进行赋值。然后catch语句块里面抛出异常。结果是抛出java.lang.NumberFormatException异常
     */
    @Test
    public void result5() {
        logger.info("=============test5返回结果：{}===============", test5());
    }

    public String test6() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (Exception e) {
            t = "catch";
            Integer.parseInt(null);
            return t;
        } finally {
            t = "finally";
            return t;
        }
    }

    /**
     * 这个例子和test5例子中唯一不同的是，这个例子里面finally 语句里面有return语句块。
     * try catch中运行的逻辑和上面例子一样，当catch语句块里面抛出异常之后，进入finally语句块，然后返回t。
     * 则程序忽略catch语句块里面抛出的异常信息，直接返回t对应的值 也就是finally。方法不会抛出异常
     */
    @Test
    public void result6() {
        logger.info("=============test6返回结果：{}===============", test6());
    }

    public String test7() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (NullPointerException e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
        }
    }

    /**
     * 这个例子里面catch语句里面catch的是NPE异常，而不是java.lang.NumberFormatException异常，
     * 所以不会进入catch语句块，直接进入finally语句块，finally对s赋值之后，
     * 由try语句抛出java.lang.NumberFormatException异常。
     */
    @Test
    public void result7() {
        logger.info("=============test7返回结果：{}===============", test7());
    }

    public String test8() {
        String t = "";

        try {
            t = "try";
            Integer.parseInt(null);
            return t;
        } catch (NullPointerException e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
            return t;
        }
    }

    /**
     * 和上面test7()的例子中try catch的逻辑相同，try语句执行完成执行finally语句，finally赋值s 并且返回s ，最后程序结果返回finally
     */
    @Test
    public void result8() {
        logger.info("=============test8返回结果：{}===============", test8());
    }

    public String test9() {
        String t = "";

        try {
            t = "try";
            return t;
        } catch (Exception e) {
            t = "catch";
            return t;
        } finally {
            t = "finally";
            String.valueOf(null);
            return t;
        }
    }

    /**
     * 这个例子中，对finally语句中添加了String.valueOf(null), 强制抛出NPE异常。
     * 首先程序执行try语句，在返回执行，执行finally语句块，finally语句抛出NPE(NullPointerException)异常，整个结果返回NPE异常。
     */
    @Test
    public void result9() {
        logger.info("=============test9返回结果：{}===============", test9());
    }
}

对以上所有的例子进行总结

  1. try、catch、finally语句中，在如果try语句有return语句，则返回的之后当前try中变量此时对应的值，此后对变量做任何的修改，都不影响try中return的返回值
  2. 如果finally块中有return 语句，则返回try或catch中的返回语句忽略。
  3. 如果finally块中抛出异常，则整个try、catch、finally块中抛出异常

所以使用try、catch、finally语句块中需要注意的是

  1. 尽量在try或者catch中使用return语句。通过finally块中达到对try或者catch返回值修改是不可行的。
  2. finally块中避免使用return语句，因为finally块中如果使用return语句，会显示的消化掉try、catch块中的异常信息，屏蔽了错误的发生
  3. finally块中避免再次抛出异常，否则整个包含try语句块的方法回抛出异常，并且会消化掉try、catch块中的异常
zhengTornado
关注
专栏目录
java中关于try, catch, finally中的细节分析
weixin_43235210的博客
07-16 142
首先来看一个程序(finally块中有return) public static int test(){ int i = 0; try{ i = 1; System.out.println("try i= "+i); return i; }catch (Excepti...
java try catch
yangyangrenren的专栏
12-30 203
import java.io.IOException; public class ExceptionTryCatchTest { public void doSomething() throws IOException{ System.out.println("do somthing"); } public static void main(String[] args){ ...
java中的异常 try catch
adam9988888的博客
07-15 227
1.学习异常的原因？ 如果没有异常处理机制，那么程序的一点小问题，都会导致【程序终止运行】。实际开发中显然是不可能的，所以异常对于程序来说是非常重要的。 2.处理异常的方式： A.if结构： 1。代码量大，代码结构不明显 2。程序员的大部分精力不是用在流程上，而是“堵漏洞”。 3。遗留一个漏洞，程序依然...
Java中的异常及try、catch、finally
qiangzhogshou的博客
08-07 221
异常 概念： Java语言将程序运行过程中所发生的不正常严重错误称为异常，对异常的处理称为异常处理。 它会中断正在运行的程序，正因为如此异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点。 我们可以进行如下两点的理解： ①出现和正常预期结果不同的情况，就叫异常。 如下情况，就会出现异常 public class Test{ public static void main(String...
java logger 异常,java使用Logger记录异常日志，javalogger日志,package cn.o
weixin_42421854的博客
03-13 182
java使用Logger记录异常日志，javalogger日志,package cn.opackage cn.outofmemory.snippets.core;import java.util.logging.Logger;import java.util.logging.Level;import java.util.Date;import java.text.DateFormat;import...
关于Java中的try-catch-finally语句和return
12-22
　第二：finally里面不建议放return语句，根据需要，return语句可以放在try和catch里面和函数的后。可行的做法有四： 　1、return语句只在函数后出现一次。 　2、return语句仅在try和catch里面都出现。 　3、...
Java try catch finally异常处理组合详解
08-19
Java try catch finally异常处理组합是Java语言中的异常处理机制，用于捕获和处理程序中的异常。下面对try catch finally异常处理组合进行详细的介绍。 try catch组合： try catch组合是Java中最基本的异常处理...
谈谈Java中try-catch-finally中的return语句
09-02
在Java编程语言中，`try-catch-finally`语句块是异常处理的关键构造，它允许程序员优雅地处理可能出现的异常情况。`return`语句则用于从方法中返回一个值或者结束方法的执行。当这两者结合在一起时，就会出现一些...
java中使用try-catch-finally一些值得注意的事(必看)
09-01
在Java编程语言中，`try-catch-finally` 结构是一种用于处理异常的关键机制。它允许程序员优雅地处理程序在运行时可能出现的错误情况，确保程序的健壮性。下面我们将详细探讨使用这三个关键字时的一些注意事项。 ...
Java异常处理之try...catch...finally详解
08-26
Java异常处理机制及实现方法主要依赖于try、catch、finally、throw和throws这五个关键字。Try关键字后跟一个花括号栝起的代码块（即使该代码块只有一行也不能省略花括号），简称try块。Catch对应异常类型和代码块，...
Java之---测试try、catch、finally、return的顺序
KAKA的博客
08-10 298
  总结执行顺序：   1、先执行try/catch   2、在执行finally   3、执行return 测试代码如下： import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * 测试try catch finally return的执...
java中的try语句块_Java try catch语句块中try（）的括号中代码作用
weixin_39829073的博客
02-16 1087
摘自：https://blog.csdn.net/qq_27092581/article/details/92839049应用场景：当我们使用带资源的try语句时，使用finally也许会造成一个异常被覆盖的问题，即try语句块中会抛出某个异常，执行finally语句块中跑出了同样的异常，这样的话就会导致原有的异常会丢失，转而抛出的finally语句中的异常。这时我们可以使用带资源的try语句来处...
JAVA调用方法统一打印日志和try/catch
吾乃南华老仙的博客
09-01 1679
需求： 避免编写重复的代码，如何把下面的两个需求抽取成公共逻辑； 1. 调用其他方法时打印被调用方法的路径、入参、以及执行耗时情况； 2. 调用方法遇到异常时，灵活控制是否要捕获异常或者抛出异常； 实现思路 使用函数式编程； 1.1. 创建一个接口（用来获取函数真实的调用路径和方法） package com.xxx.utils.function; import java.io.Serializable; import java....
try catch之后把错误日志打印出来
一寸一寸光阴
09-05 8561
学习博客 try catch 日志打印详细出错信息，包括出错位置 - heamin-java - 博客园 (cnblogs.com) 需求 项目中有的时候会用try catch包裹错误，然后即使出错也让流程继续走下去，但是为了及时知道错误需要把错误日志打印出来，然后有一天忽然发现错误日志根本在服务器中都没有打印出来 以前我是这样写得=====实际堆栈信息没打 try{ //业务代码 } catch (Exception e) { .
try catch 嵌套
qq_44209563的博客
03-23 7119
实践测试 在单元测试中写入以下方法: testMain()主方法, out()里面嵌套了两层try catch 异常代码写在内层try中 示例一： @Test public void testMain(){ out(); log.info("后续处理业务"); } public void out(){ //外层try try { System.out.println("外层输出");
java logger错误_java – 如何使用logger打印异常？
weixin_42292183的博客
02-16 339
我有一种情况,我想使用记录器打印捕获在catch块中的所有异常.try {File file = new File("C:\\className").mkdir();fh = new FileHandler("C:\\className\\className.log");logger.addHandler(fh);logger.setUseParentHandlers(false);SimpleF...
java在异常处理(catch)中生成日志
Sife_007的博客
08-30 1303
public class LoggingException2 { private static Logger logger=Logger.getLogger("LoggingException2"); static void logException(Exception e){ StringWriter trace=new StringWriter();
Java 提高（4）----- 异常 Logger
chenqianleo的博客
08-31 1881
异常 Logger推荐博客 http://blog.csdn.net/hguisu/article/details/6155636异常分类 所有的异常有Throwable（直接继承了Object）继承而来，有两个子类Error和Exception Error , 描述了java运行时系统的内部错误和资源耗尽错误，应用程序不应该抛出这种类型的错误，当出现了这种错误，我们只能告诉使用者错误类型，安全的
java logerror_关于java：如何使用logger打印异常？
weixin_30573089的博客
02-24 1815
在这种情况下，我希望使用logger打印catch块中捕获的所有异常。try {File file = new File("C:\\className").mkdir();fh = new FileHandler("C:\\className\\className.log");logger.addHandler(fh);logger.setUseParentHandlers(false);Simp...
Java中的try catch finally语句
最新发布
07-21
在 Java 中，try-catch-finally 语句用于捕获和处理异常。它的基本语法如下： ```java try { // 可能会抛出异常的代码块 } catch (ExceptionType1 e1) { // 处理异常类型1的代码块 } catch (ExceptionType2 e2) { // 处理异常类型2的代码块 } finally { // 无论是否发生异常，都会执行的代码块 } ``` 在 try 块中，你可以放置可能会抛出异常的代码。如果在执行 try 块中的代码时发生了异常，那么就会跳到相应的 catch 块中进行异常处理。catch 块可以有多个，每个 catch 块用于捕获不同类型的异常，并提供相应的处理逻辑。catch 块中的参数 e1、e2 是异常对象，你可以使用它们来获取有关异常的信息。 无论是否发生异常，finally 块中的代码都会被执行。finally 块通常用于释放资源或执行清理操作，确保在任何情况下都会执行。 如果在 try 块中发生了异常，并且没有相应的 catch 块来处理该异常，那么该异常将被传递给上层调用栈，直到找到合适的 catch 块进行处理，或者如果没有找到任何 catch 块，则程序将终止。 以下是一个简单的示例： ```java try { int result = divide(10, 0); System.out.println("结果：" + result); } catch (ArithmeticException e) { System.out.println("除数不能为零！"); } finally { System.out.println("finally 块中的代码"); } public static int divide(int dividend, int divisor) { return dividend / divisor; } ``` 在上面的示例中，divide 方法会抛出一个 ArithmeticException 异常，因为除数为零。在 catch 块中，我们对该异常进行处理，并输出相应的信息。无论是否发生异常，finally 块中的代码都会执行，输出 "finally 块中的代码"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值