return和finally的执行顺序问题

最新推荐文章于 2024-08-09 18:14:32 发布
最新推荐文章于 2024-08-09 18:14:32 发布
阅读量103 收藏
点赞数
分类专栏： Java 文章标签： 测试 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_7011/article/details/82607048
版权

一、引言

      当try里面有return，finally里面也有return时会有怎么的结果呢？

二、代码 

      话不多说，直接用代码进行测试。测试代码如下，

public class FinallyTest {
	
private static final FinallyTest instance = new FinallyTest("instance");
	
         /**
	 * @param value
	 */
	private FinallyTest(String value) {
		super();
		this.value = value;
	}

	private String value;

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	/**
	 * <p>测试基本类型
	 * @return
	 */
	public int testReturnInt() {
		int b = 60;
		try {
			System.out.println("testReturnInt() in try. b = " + b);
//			throw new NullPointerException();
			 return b += 50;
		} catch (Exception e) {
			System.out.println("testReturnInt() in catch. b = " + b);
//			return b +=100;
		}finally {
			System.out.println("finally before edit. b = " +b);
			b = 2000;
			System.out.println("finally after edit. b= " + b);
		    return b;
		}
//		System.out.println("out of finally");
//		return b + 1000;
	}

	/**
	 * <p>测试对象 
	 * @return
	 */
	public FinallyTest testReturnObj() {
		FinallyTest demo = new FinallyTest("origin");
		try {
			System.out.println("testReturnObj() in try. value = " + demo.getValue());
			return demo;
		} catch (Exception e) {
			System.out.println("testReturnObj() in catch. value = " + demo.getValue());
		} finally {
			System.out.println("finally before edit. value = " + demo.getValue());
			demo.setValue("modified");
			System.out.println("finally after edit. value = " + demo.getValue());
		    return demo;
		}
//		System.out.println("out of finally");
//		return demo;
	}

	public static void main(String[] args) {
		System.out.println("in main. int =" + instance.testReturnInt()+"\n*************");
		System.out.println("in main. value = " + instance.testReturnObj().getValue());
	}	  

}

    注意：上面这种return的方式（即在finally里面加上return），在eclipse里面会出现"finally block does not complete normally"的警告，下文会对此作一个说明。这里因为要举例，仍然暂时这么写。

 

三、测试用例

   把try,catch,finally的情况分为三种：

   1.try和finally型（即上文中的代码）：

try{
  return a = xxx;
}catch(Exception e){
  xxx
}finally{
  return a = xxxx;
}
   终端输出： 
testReturnInt() in try. b = 60
finally before edit. b = 110
finally after edit. b= 2000
in main. int =2000
*************
testReturnObj() in try. value = origin
finally before edit. value = origin
finally after edit. value = modified
in main. value = modified
   结论：不论是基本类型还是引用对象，finally里面的return都会覆盖try里的return，这种方式不推荐。
    2.catch和finally型： 
try{
  xxx;
}catch(Exception e){
  return a = xxx;
}finally{
  return a = xxxx;
}

   相应地把testReturnInt()和testReturnObj()的return移动到catch里面，其他不变：

	/**
	 * <p>测试基本类型
	 * @return
	 */
	public int testReturnInt() {
		int b = 60;
		try {
			System.out.println("testReturnInt() in try. b = " + b);
//			throw new NullPointerException();
//			 return b += 50;
//			return b+50;
		} catch (Exception e) {
			System.out.println("testReturnInt() in catch. b = " + b);
			return b +=50;
		}finally {
			System.out.println("finally before edit. b = " +b);
			b = 2000;
			System.out.println("finally after edit. b= " + b);
		    return b;
		}
//		System.out.println("out of finally");
//		return b + 1000;
	}

	/**
	 * <p>测试对象 
	 * @return
	 */
	public FinallyTest testReturnObj() {
		FinallyTest demo = new FinallyTest("origin");
		try {
			System.out.println("testReturnObj() in try. value = " + demo.getValue());
//			throw new NullPointerException();
//			return demo;
		} catch (Exception e) {
			System.out.println("testReturnObj() in catch. value = " + demo.getValue());
			return demo;
		} finally {
			System.out.println("finally before edit. value = " + demo.getValue());
			demo.setValue("modified");
			System.out.println("finally after edit. value = " + demo.getValue());
		    return demo;
		}
//		System.out.println("out of finally");
//		return demo;
	}
    终端输出： 
testReturnInt() in try. b = 60
finally before edit. b = 60
finally after edit. b= 2000
in main. int =2000
*************
testReturnObj() in try. value = origin
finally before edit. value = origin
finally after edit. value = modified
in main. value = modified
     可以看到,由于没有异常，所以不会走catch分支，因此基本类型的值在finally before edit处不变，而引用对象的值由于是在finally里中set，因此仍然发生了变化。
    如果把try中throw new NullPointerException();这句话的注释去掉，从而走catch分支，那么输出结果就和情况1是一样的。即基本类型的值在finally before edit处发生变化。
   但从最终结果来看：不论是否发生异常，finally里面的return都是最终返回的值，即都会覆盖catch中的return。

   3.try,catch,finally型

try{
  xxx;
  return a = xxx;
}catch(Exception e){
  return a = xxx;
}finally{
  return a = xxxx;
}

   修改testReturnInt()和testReturnObj()如下：，通过传入不同的参数来决定是否走catch分支：

	/**
	 * <p>
	 * 测试基本类型
	 * 
	 * @return
	 */
	public int testReturnInt(int i) {
		int b = 60;
		try {
			System.out.println("testReturnInt() in try. b = " + b);
			if (i == -1) {
				throw new NullPointerException();
			} else {
				return b += 50;
			}
			// return b+50;
		} catch (Exception e) {
			System.out.println("testReturnInt() in catch. b = " + b);
			return b += 50;
		} finally {
			System.out.println("finally before edit. b = " + b);
			b = 2000;
			System.out.println("finally after edit. b= " + b);
			return b;
		}
		// System.out.println("out of finally");
		// return b + 1000;
	}

   这里基本上是对上述情况1和情况2的结合。不再给出具体的终端输出，结论仍然和情况1和情况2类似，即fianlly里面的return会对前面的return（不论是try还是catch分支进行覆盖）。

  

  四、细心的同学应该会发现，其实我们还少了一种情况： 

  

try{
xxx;
return a = xxx;
}catch(Exception e){
a=xxx;
}finally{
xxx;
a = xxxx;
}
System.out.println("out of finally");
a=xxx;
return a;
    代码修改如下：

 

 

	/**
	 * <p>
	 * 测试基本类型
	 * 
	 * @return
	 */
	public int testReturnInt(int i) {
		int b = 60;
		try {
			System.out.println("testReturnInt() in try. b = " + b);
			if (i == -1) {
				throw new NullPointerException();
			}
			return b += 50;
		} catch (Exception e) {
			System.out.println("testReturnInt() in catch. b = " + b);
			// return b += 50;
		} finally {
			System.out.println("finally before edit. b = " + b);
			b = 2000;
			System.out.println("finally after edit. b= " + b);
			// return b;
		}
		System.out.println("out of finally");
		return b;
	}

	/**
	 * <p>
	 * 测试对象
	 * 
	 * @return
	 */
	public FinallyTest testReturnObj(Object object) {
		FinallyTest demo = new FinallyTest("origin");
		try {
			System.out.println("testReturnObj() in try. value = "
					+ demo.getValue());
			if (object == null) {
				throw new NullPointerException();
			} 
			return demo;
		} catch (Exception e) {
			System.out.println("testReturnObj() in catch. value = "
					+ demo.getValue());
			// return demo;
		} finally {
			System.out.println("finally before edit. value = "
					+ demo.getValue());
			demo.setValue("modified");
			System.out
					.println("finally after edit. value = " + demo.getValue());
			// return demo;
		}
		System.out.println("out of finally");
		demo.setValue("out of finally");
		return demo;
	}

	public static void main(String[] args) {
		System.out.println("in main. int =" + instance.testReturnInt(0)
				+ "\n*************");
		System.out.println("in main. value = "
				+ instance.testReturnObj(new Object()).getValue());
	}
    终端输出：

 

 

testReturnInt() in try. b = 60
finally before edit. b = 110
finally after edit. b= 2000
in main. int =110
*************
testReturnObj() in try. value = origin
finally before edit. value = origin
finally after edit. value = modified
in main. value = modified
     正常情况下会执行 try中的return，finally中的代码也会执行，但是finally外面的代码不会执行。 另外值得注意的是，基本类别的值在finally中发生了变化（对应输出中的：finally after edit. b= 2000），但是最终返回到main中的值仍然是try中的return ，即finally中的对基本类类型的修改是无效的（即对调用方是无效的）；然而finally中对引用对象的修改却是有效的。

 

 

       出现异常时会执行finally外面的return。这里不再作截图，读者有兴趣可以自行测试。

       可见这种情况下a的值最多有可能在四个地方被改变，程序极易出现混乱，可读性很差，因此极其不推荐。

 

 

四、结论

     终上，finally有return时，finally里面的return会覆盖原来的数据，而且也会修改原来的对象引用（基本类型数据不变----除非在finally之后有return语句）。所以，为了避免混乱，建议不要在finally里面写return。一般采用如下形式：

try{
xxx;
a=xxx;
return a;
}catch(Exception e){
xxx;
a=xxx;
return a;
}finally{
 xxx;
}

   或者统一在最后作return

 

try{
xxx;
a=xxx;
}catch(Exception e){
xxx;
a=xxx;
}finally{
 xxx;
}
return a;
    即finally里面不要作return（如非必要也尽量不要对返回的数据作修改），只作一些必要的关闭资源的工作。
iteye_7011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于Java中try finally return语句的执行顺序浅析
08-29
"Java中try finally return语句的执行顺序浅析" 关于Java中try finally return语句的执行顺序浅析是Java语言中一个重要的知识点，今天我们来探讨一下try finally return语句的执行顺序。 首先，需要了解的是...
try catch finally的执行顺序深入分析
09-05
在编程语言中，异常处理是一种重要的错误处理机制，它允许我们优雅地捕获并处理运行时可能出现的问题。...理解这个执行顺序对于编写健壮的代码至关重要，特别是在处理资源管理和异常恢复的场景下。
关于finally的一些常见问题
zhong592489824的博客
07-25 988
关于finally 对于很多程序员来说，比如笔者我，对异常的理解就是使用try catch或者throws对异常进行处理，最多再加一个throw new RuntimeException。但是只做到这一步是无法应付面试官的，更无法有效的解决程序中遇到的问题。在此，笔者将着重讲解一下与异常相关的finally。 我们都知道finally是跟在try catch之后才执行的，无论有没有异常它都一定会执行，因此它常常被用来关闭连接，或释放资源。例如在关闭jdbc的连接： 2.finally区域的内容一定会执行
finally和return的执行顺序
热门推荐
Rad的博客
05-22 5万+
今天看到一段代码，try中有return语句，后面还有一个finally，不知道执行过程是什么样的。于是来试验了一下。 1.try和catch中有return时，finally里面的语句会被执行吗 我们可以来分别看看 (1)执行try中的return时 public class tryDemo { public static int show() { try ...
浅谈Java中return和finally的问题
09-03
2. **`return` 与 `finally` 的执行顺序**：在 `try` 块中遇到 `return` 时，会先执行 `finally` 语句块，然后再返回值。这是因为 `finally` 中的代码优先级高于 `return`，即使 `return` 已经被触发，`finally` ...
try、catch、finally、return 执行顺序.doc
09-09
下面我们来详细讲解 try、catch、finally、return 执行顺序的规则和特点。 首先，我们需要了解 try、catch、finally 语句的基本用法。try 语句用于包装可能抛出异常的代码，catch 语句用于捕捉 try 语句中的异常，...
try-catch-finally执行顺序验证
01-20
try-catch-finally执行顺序验证(左边是.java文件，右边是.class文件) 提示： try、catch块内的return操作编译后会变成把return的值保存到变量var的操作。 总结: try、catch块内的return操作编译后会变成把return的值...
【JS开源库】基于最小二乘法的离散点拟合圆形，计算圆心坐标和半径
blucod的博客
08-09 215
一个用于快速拟合一组二维点的JavaScript库。代码量少，可自行用Java、C#等语言重写。
使用maven打包项目报错Please refer to...
大白的Java之旅
08-08 131
在 pom.xml 中添加如下配置。
15：00面试，15：08就出来了，问的问题有点变态。。。
2301_78276982的博客
08-05 1万+
整份文档一共有将近 200 页，全部为大家展示出来肯定是不太现实的，为了不影响大家的阅读体验就只展示了部分内容，还望大家海涵，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习！
Javaweb--java基础
weixin_51933701的博客
08-09 89
黑盒测试又称为功能测试或数据驱动测试，不关心程序内部结构和逻辑，只关注程序输出是否符合预期。测试者只需知道软件的输入和应有的输出，而不需要知道软件内部的实现。这种测试主要用来检查软件的功能点是否能正常工作，比如用户界面和用户操作的正确性。
C语言 软件设计的七大原则，及其应用案例
qq_19343801的博客
08-08 349
一个模块或函数应当只有一个引起变化的原因。
初识Spring、SpringIOC
weixin_65978343的博客
08-05 918
Spring面试------对Spring的理解\Spring框架由哪些模块组成？\对Spring IOC的理解\ Spring IOC容器的理解\ Spring IOC的实现步骤
组合数的低复杂度运算
rc85qbte的博客
08-08 689
† 如果数组 b 可以通过从 a 中删除几个（可能是零个或全部）元素来获得，则数组 b 是数组 a 的子序列。子序列不必是连续的。基础的组合数问题，不需要多少分析，针对每一种1占据多数的子字符串情况进行组合数目加和就可以主要是算法空间时间复杂度的问题。每条测试用例第一行包含两个整数n和k（1≤k≤n≤2105，k为奇数），分别为数组的长度和子序列。他将取该数组中所有长度为 k（k 为奇数）的子序列并找到它们的中位数。奇数长度 k 的数组的中位数是排序后的第 +1 个元素。二进制数组是仅由零和一组成的数组。
Falsk测试与部署（第九阶段）
蜡笔小新星的博客
08-09 307
在本章节中，我们学习了如何使用unittest和pytest进行单元和集成测试，以及如何配置Flask应用，使用WSGI服务器部署，容器化Flask应用并将其部署到各种云服务平台。通过这些步骤，你可以确保你的Flask应用在生产环境中的稳定性和可靠性。希望这些知识能够帮助你在实际项目中更好地实现测试和部署。
【Python问题集锦】如何有效的模拟用户操作
苏凉.py的博客
08-07 285
在一个自动化测试项目中，我们需要对一个Web应用进行功能测试。测试过程中遇到的问题是：如何有效地模拟用户操作并验证不同页面元素的状态。
Selenium + Python 自动化测试09（多窗口切换）
最新发布
立黄昏粥可温
08-09 416
我们的目标是：按照这一套资料学习下来，大家可以独立完成自动化测试的任务。上一篇我们讨论了截图的操作方法，本篇文章我们讲述一下多窗口切换的操作方法。在实际的测试项目组中我们可能会遇到多窗口的情况，有时候需要在不同窗口进行切换，下面详细讲述一下具体的操作方法。
《最新出炉》系列小成篇-Python+Playwright自动化测试-67 - 模拟手机浏览器兼容性测试
北京-宏哥的博客
08-07 1100
在日常工作中，我们会遇到需要使用不同的硬件设备测试兼容性的问题，尤其是现在手机型号基本上是每个厂家每年发布一款新机型，而且手机的屏幕大小分辨率五花八门的，我们基本不可能全部机型都用真机测试一遍，playwright提供了模仿机型的功能，我们可以使用playwright来模拟设备。使用 Playwright，你可以在任何浏览器上测试你的应用程序，也可以模拟真实设备，例如手机或平板电脑。
SpringBoot3 响应式编程
萧曳丶
08-09 308
响应式编程是一种编程范式，它使用异步数据流来处理数据，并基于观察者模式来触发事件的响应。在Spring Boot 3中，响应式编程主要通过Spring WebFlux和Spring Data R2DBC等组件来实现。Spring Boot 3中的响应式编程通过Spring WebFlux和Spring Data R2DBC等组件提供了强大的异步、非阻塞和基于事件的数据处理能力。这使得开发者能够构建高性能、可扩展的Web应用程序，以应对现代互联网应用中的高并发和实时数据处理挑战。
try catch finally return执行顺序
04-11
try catch finally return 执行顺序是先执行 try 代码块中的语句，如果有异常则跳到 catch 代码块中处理异常，finally 代码块最后执行，最后执行 return 语句返回结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值