`
joknm
  • 浏览: 62848 次
  • 性别: Icon_minigender_1
  • 来自: 南宁
社区版块
存档分类
最新评论

finally 浅谈

    博客分类：
  • JAVA
 
阅读更多
近日做程序时突发奇想：try ... finally ... 中的 finally 会在返回前执行（在XXX书上看到的，忘了书名了），是于做了以下测试 
public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
			return returnString;		
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
		}		
	}
}

测试结题： 
execute finally...
before clean returnString's value: this string will be return.
after  clean returnString's value: null
execute finally end.
return: this string will be return.

如果返回前执行，那么返回的字符串应该为空。但从结果来看，似乎出人的意料之外。
考虑原因：返回前将返回的结果拷贝了。

于是做了以下修改： 
public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getMessage().message);
	}
	
	public Message getMessage()
	{
		Message returnMessage = new Message();
		try
		{
			returnMessage.message = "message";
			return returnMessage;		
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnMessage.message);
			returnMessage.message = null;
			System.out.println("after  clean returnString's value: " + returnMessage.message);
			System.out.println("execute finally end.");
		}		
	}
}

class Message
{
	public String message = "message";
}


结果： 
execute finally...
before clean returnString's value: message
after  clean returnString's value: null
execute finally end.
return: null

从结果来看，只调用了对象的引用，而对象没有被拷贝。
看来，如所下用 finally 统一处理一般数据类型还是免谈了。 
public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getInt());
	}
	
	public int getInt()
	{
		int returnInt = 0;
		try
		{
			returnInt = 1;
			throw new RuntimeException("...");
		}catch(Exception e)
		{
			returnInt = 2;
			return returnInt;
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before switch returnInt's value: " + returnInt);
			switch(returnInt)
			{
				case 1:
					returnInt = 0;
					break;
				case 2:
					returnInt = 3;
					break;
				default:
					returnInt = 4;
			}
			System.out.println("after  switch returnInt's value: " + returnInt);
			System.out.println("execute finally end.");
		}		
	}
}
分享到：
| linux mysql 安装
评论
21 楼 sakajiaofu 2010-07-30  
public   class   Test22{  
  public   static   void   main(String[]   args){  
  System.out.print(tt());  
  }  
  public   static   int   tt(){  
  int   b   =   23;  
  try{  
  System.out.println("yes");  
  return   b=88;   ***************************************1
  }  
  catch(Exception   e){  
  System.out.println("error   :   "   +   e);  
  }  
  finally{  
  if(b>25){  
  System.out.println("b>25   :   "+b);  
  }  
  System.out.println("finally");  
  }  
  return   b;  
  }  
  }  
   
   
  执行结果：  
  yes  
  b>25   :   88  
  finally  
  88  

执行到1处时， return   b = 88;其实是先执行了b   =   88这个计算，并把计算结果的地址保存在一个临时的局部变量中（应该是把88压入栈），然后开始执行finally子句，finally执行完毕后，再从先前的临时变量中取得返回地址，返回方法的最终结果。根据这样的处理方式，可以试验，当我们试图在finally子句中再行改变b的值时，已经不会对方法的返回结果造成影响。


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jhr924/archive/2009/05/22/4207690.aspx
20 楼 西门吹牛 2010-07-30  
支持 返回引用(returnPointer) 的说法，还有对于先return后finally的说法
是不是这样的
returnPointer=obj；
  之后执行fianlly；
然后 return  returnPointer；
19 楼 gstarwd 2010-07-30  
hardPass 写道
wujiazhao88 写道
楼主你试下这个程序看看，看看能不能猜到运行结果。 

public class Danteng{
public static void main(String[] args){
 doSomething();
}

static void doSomething(){

try{
 System.out.println("try...");
 doSomething();
}finally{
System.out.println("finally");
doSomething();
}
}

}




为什么这种情况也执行"finally"?
没想明白……

为什么不执行呢？
18 楼 hardPass 2010-07-30  
wujiazhao88 写道
楼主你试下这个程序看看，看看能不能猜到运行结果。 

public class Danteng{
public static void main(String[] args){
 doSomething();
}

static void doSomething(){

try{
 System.out.println("try...");
 doSomething();
}finally{
System.out.println("finally");
doSomething();
}
}

}




为什么这种情况也执行"finally"?
没想明白……
17 楼 zhao103804 2010-07-30  
fyf_008 写道
楼主回答有些许问题。。

对象绝对没有 Copy. 或者说是克隆。你要用Java，就要知道Java的设计者如何设计java .这问题就解决


那为什么呢，

return obj;

只是 将返回引用(returnPointer)，指向了obj 这个引用 指向的对象，

并没有Copy,

虽然，你在 finally 里面，把obj=null;
那只是， obj 这个引用，指向发生了变化，没有影响返回引用（returnPointer）



这个就是指针的概念了
16 楼 linqs083 2010-07-30  
finally 只知道是一定要跑，不管啥情况
15 楼 joy2everyone 2010-07-30  
wujiazhao88 写道
楼主你试下这个程序看看，看看能不能猜到运行结果。 

public class Danteng{
public static void main(String[] args){
 doSomething();
}

static void doSomething(){

try{
 System.out.println("try...");
 doSomething();
}finally{
System.out.println("finally");
doSomething();
}
}

}




有点邪恶
14 楼 joy2everyone 2010-07-30  
yangguo 写道

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
			return returnString;		
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
		}		
	}
}


以上一段相当于以下，所以根本没有错。就喜欢简单问题复杂化。 

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
                         System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
			return returnString;		
		}finally
		{			
			
		}		
	}
}



真的是相当吗？我觉得应该不是相当的，

按照“先返回再执行finally”的方式来整理代码思路，LZ提出的两个例子都可以预期到执行结果
13 楼 gstarwd 2010-07-30  
fyf_008 写道
楼主回答有些许问题。。

对象绝对没有 Copy. 或者说是克隆。你要用Java，就要知道Java的设计者如何设计java .这问题就解决


那为什么呢，

return obj;

只是 将返回引用(returnPointer)，指向了obj 这个引用 指向的对象，

并没有Copy,

虽然，你在 finally 里面，把obj=null;
那只是， obj 这个引用，指向发生了变化，没有影响返回引用（returnPointer）


理解的很深刻~~很不错 我要多多向这位仁兄学习~
12 楼 tottichen 2010-07-29  
不知道楼主想说明什么问题
11 楼 pop1030123 2010-07-29  
楼上的类名起得比较好！！！
10 楼 wujiazhao88 2010-07-29  
楼主你试下这个程序看看，看看能不能猜到运行结果。 

public class Danteng{
public static void main(String[] args){
 doSomething();
}

static void doSomething(){

try{
 System.out.println("try...");
 doSomething();
}finally{
System.out.println("finally");
doSomething();
}
}

}

9 楼 笑我痴狂 2010-07-29  
yangguo 写道

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
			return returnString;		
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
		}		
	}
}


以上一段相当于以下，所以根本没有错。就喜欢简单问题复杂化。 

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
                         System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
			return returnString;		
		}finally
		{			
			
		}		
	}
}




如果是这样的话  也不能解释得到的结果吧
8 楼 坏孩子 2010-07-29  
<p>
</p>
<pre name="code" class="java">public java.lang.String getString();
  Code:
   0:   aconst_null
   1:   astore_1
   2:   ldc     #48; //String this string will be return.
   4:   astore_1
   5:   aload_1
   6:   astore_3
   7:   getstatic       #16; //Field java/lang/System.out:Ljava/io/PrintStream;
   10:  ldc     #50; //String sss
   12:  invokevirtual   #41; //Method java/io/PrintStream.println:(Ljava/lang/St
ring;)V
   15:  aconst_null
   16:  astore_1
   17:  aload_3
   18:  areturn
   19:  astore_2
   20:  getstatic       #16; //Field java/lang/System.out:Ljava/io/PrintStream;
   23:  ldc     #50; //String sss
   25:  invokevirtual   #41; //Method java/io/PrintStream.println:(Ljava/lang/St
ring;)V
   28:  aconst_null
   29:  astore_1
   30:  aload_2
   31:  athrow</pre>

<p> </p>
<p>
</p>
<pre name="code" class="java"> public String getString() {
String returnString = null;
try {
returnString = "this string will be return.";
return returnString;
} finally {
System.out.println("sss");
returnString = null;
}
}</pre>
 
<p> </p>
<p>其实是先返回再执行finally</p>
<p> </p>
7 楼 guanliScott 2010-07-29  
容易误导人，投了隐藏贴。
6 楼 fyf_008 2010-07-29  
可能还是有人看不懂。。
我来说明下。 

public class A{
   public String m(){
     //xxxx代码
     
     return obj;// return obj ,只是把obj 指向的地址，交给 returnAddress; finally 里面的代码，在这步后运行
   }
}

//Java会以下面的方式来执行，翻译成下面的


public class A{
   public String m(){
     //xxxx代码
     
     Object returnPointer=obj;// 你看不见的隐式 引用，Java每个方法，都返回一个 返回
     return (String)returnPointer;
   }
}



其实，你的代码相当于

  
 1. public class FinallyTest   
   2. {  
   3.     public static void main(String args[])  
   4.     {  
   5.         System.out.println("return: " + new FinallyTest().getString());  
   6.     }  
   7.       
   8.     public String getString()  
   9.     {  
  10.         String returnString = null;  
  11.         try  
  12.         {  
  13.             returnString = "this string will be return.";  
     ############    String returnPointer=returnString;// 隐式的，看不到。。。。。###################
  14.             return returnPointer;  //##############################        
  15.         }finally  
  16.         {             
  17.             System.out.println("execute finally...");  
  18.             System.out.println("before clean returnString's value: " + returnString);  
  19.             returnString = null;  
  20.             System.out.println("after  clean returnString's value: " + returnString);  
  21.             System.out.println("execute finally end.");  
  22.         }         
  23.     }  
  24. }


这下，这个方法的返回值，当然不为空了。。。。。。。。。
5 楼 fyf_008 2010-07-29  
楼主回答有些许问题。。

对象绝对没有 Copy. 或者说是克隆。你要用Java，就要知道Java的设计者如何设计java .这问题就解决


那为什么呢，

return obj;

只是 将返回引用(returnPointer)，指向了obj 这个引用 指向的对象，

并没有Copy,

虽然，你在 finally 里面，把obj=null;
那只是， obj 这个引用，指向发生了变化，没有影响返回引用（returnPointer）

4 楼 peacenik 2010-07-29  
“返回前将返回的结果拷贝了。” 应该是拷贝了对象的引用
基本数据类型和String的值是不能改变的，基本数据类型和String的值改变后，变量的引用也改变了，但return 返回前的拷贝的引用却没有变，所以 new FinallyTest().getString() 的值是“this string will be return.”
改变Message.message的值对象的引用是没有变化的，所以
new FinallyTest().getMessage().message 返回 null 
3 楼 zhengtianbing123 2010-07-29  
学习了,
2 楼 yangguo 2010-07-29   

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
			return returnString;		
		}finally
		{			
			System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
		}		
	}
}


以上一段相当于以下，所以根本没有错。就喜欢简单问题复杂化。 

public class FinallyTest 
{
	public static void main(String args[])
	{
		System.out.println("return: " + new FinallyTest().getString());
	}
	
	public String getString()
	{
		String returnString = null;
		try
		{
			returnString = "this string will be return.";
                         System.out.println("execute finally...");
			System.out.println("before clean returnString's value: " + returnString);
			returnString = null;
			System.out.println("after  clean returnString's value: " + returnString);
			System.out.println("execute finally end.");
			return returnString;		
		}finally
		{			
			
		}		
	}
}


发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    浅谈Java中return和finally的问题

    在Java编程语言中，`return` 语句和 `finally` 语句的相互作用是一个重要的概念，尤其是在处理异常处理时。`finally` 语句块通常用于确保某些代码无论是否发生异常都会被执行，而 `return` 语句用于提前结束方法并...

    浅谈java！

    - **异常处理**：学会正确使用try-catch-finally语句处理异常情况。 - **输入输出流**：熟悉文件读写操作，包括文本文件和二进制文件的处理。 - **泛型与注解**：了解泛型和注解的使用方法及其重要性。 #### 二、...

    浅谈Java异常.pdf

    同时，Java也提供了finally代码块，无论是否发生异常，finally块中的代码都会被执行。 异常处理并不是异常程序的首选方式，而是程序的一种补充手段。在编写程序时，应当尽量预防异常的发生，比如进行输入数据的校验...

    浅谈java之IO学习经验

    } finally { try { if (fis != null) fis.close(); if (fos != null) fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } ``` ### 总结 本文介绍了Java IO的基础知识，包括流的概念、...

    浅谈Java finally语句到底是在return之前还是之后执行(必看篇)

    Java 中 finally 语句的执行顺序探讨 在 Java 中，finally 语句的执行顺序是一个常见的探讨话题。很多人都认为 finally 语句一定会被执行，但这是不正确的。在某些情况下，finally 语句可能不会被执行，例如在 try ...

    Java分布式应用学习笔记06浅谈并发加锁机制分析

    ### Java分布式应用学习笔记06浅谈并发加锁机制分析 #### 1. 前言 在深入探讨Java中的并发加锁机制之前，我们有必要回顾一下多线程环境下的一些基本概念和技术。之前的多线程调度、并发调度以及线程加锁安全等内容...

    浅谈软件安全设计（一）

    浅谈软件安全设计（一） code by 黑夜彩虹 & vxin with almost pure delphi 网站：http://soft.eastrise.net 2007-03-07 --- 转载时请保留作者信息。 **************************************...

    浅谈基于Java的异常处理机制.pdf

    异常处理的三个主要概念是：异常类（Exception），异常处理语句（try, catch, finally），以及异常对象。异常类是在程序中定义异常条件的类。异常处理语句用于捕获和处理异常，而异常对象则是通过异常类的实例化而...

    浅谈西门子PLC的SCL语言编程_SCL手册_scl教程_

    西门子PLC的SCL（Structured Control Language）是一种基于IEC 61131-3标准的高级编程...通过阅读"浅谈西门子PLC的SCL语言编程.pdf"这份教程，新手可以逐步掌握SCL编程的核心概念和技巧，从而在自动化领域中得心应手。

    浅谈使用ADO.NET和ASP.NET访问SQL Server数据库.pdf

    由于提供的【部分内容】中大部分内容均为乱码，无法从中提取出有意义的IT知识点，但是根据标题“浅谈使用***和***访问SQL Server数据库.pdf”和【描述】中的重复标题，我们可以推断出本文档的主要内容。以下将围绕**...

    java之浅谈深说--教你如何成长

    ### Java之浅谈深说——教你如何成长为Java编程高手 在IT行业中，Java作为一种广泛使用的编程语言，其重要性不言而喻。对于希望成为Java编程高手的学习者来说，掌握正确的学习路径至关重要。本文将根据提供的标题、...

    浅谈Java自定义异常在教学中的教与学

    在代码块中可能发生异常的位置，可以使用try块来包含可能发生异常的代码，使用catch块来捕获和处理异常，而finally块则用于定义无论是否发生异常都需要执行的代码，比如释放资源、关闭文件等。 在Java程序设计语言...

    浅谈Python中的异常和JSON读写数据的实现

    - `finally`：可选，无论是否有异常发生，都会执行此块中的代码，通常用于释放资源等操作。 #### 示例分析 文章中的示例代码展示了如何使用异常处理来优雅地处理分母为零的情况： ```python def division...

    浅谈JavaScript异常处理语句

    此外，try-catch-finally结构还包括了finally块，无论try块中是否发生错误，finally块中的代码都会执行。这通常用于资源清理，比如关闭文件句柄、释放DOM元素引用等，确保程序的资源得到妥善处理，防止内存泄漏。 ...

    论文研究-基于Java异常处理机制的研究 .pdf

    Java异常处理结构包括try、catch和finally三个基本代码块。 - try块用于包裹可能会抛出异常的代码段。 - catch块用于捕获try块中抛出的异常，可以有多个catch块来捕获不同类型的异常。 - finally块用于执行清理工作...

    浅谈Java并发编程之Lock锁和条件变量

    "浅谈Java并发编程之Lock锁和条件变量" Lock锁是Java并发编程中的一种重要机制，它提供了比synchronized更加广泛的锁定操作。Lock接口有三种实现类：ReentrantLock、ReetrantReadWriteLock.ReadLock和...

    浅谈java异常处理之空指针异常

    1. `try`块不能单独存在，必须与`catch`、`finally`配合使用，形成`try...catch...finally`、`try...catch`或`try...finally`结构。 2. `try`、`catch`、`finally`块中的变量作用域独立，无法相互访问。若需共享变量...

    浅谈Python的异常处理

    5. `finally`: 不管是否发生异常，`finally`块中的代码都会被执行。这对于资源清理（如关闭文件、网络连接）非常有用。 6. `else`: 如果`try`块中的代码没有引发异常，那么`else`块的代码将会被执行。这通常用于在...

    浅谈java异常链与异常丢失

    异常丢失通常发生在`try-catch-finally` 结构中，特别是当finally块中抛出了新的异常，可能导致前面try块中抛出的异常信息丢失。如下所示： ```java public class MyTest { public void open() throws Exception {...

Magicbox
Global site tag (gtag.js) - Google Analytics