讲解Java编程中finally语句的基本使用方法

这篇文章主要介绍了讲解Java编程中finally语句的基本使用方法,finally在异常处理中的使用时Java入门学习中的基础知识,需要的朋友可以参考下

在java中的finally关键一般与try一起使用，在程序进入try块之后，无论程序是因为异常而中止或其它方式返回终止的，finally块的内容一定会被执行，写个例子来说明下：

1. public class TryAndFinallyTest {  
2.  
3. public static void main(String[] args) throws Exception{  
4. try{  
5. int a = testFinally(2);  
6. System.out.println("异常返回的结果a:"+a);  
7. }catch(Exception e){  
8. int b = testFinally(1);  
9. System.out.println("正常返回的结果b:"+b);  
10. }  
11. int b = testFinally(3);  
12. System.out.println("break返回的结果:"+b);  
13.  
14. b = testFinally(4);  
15. System.out.println("return返回的结果:"+b);  
16.  
17. }  
18.  
19. static int testFinally(int i) throws Exception{  
20. int flag = i;  
21. try{//一旦进去try范围无论程序是抛出异常或其它中断情况，finally的内容都会被执行  
22. switch(i){  
23. case 1:++i;break;//程序 正常结束  
24. case 2:throw new Exception("测试下异常情况");  
25. case 3:break;  
26. default :return -1;  
27. }  
28. }finally{  
29. System.out.println("finally coming when i="+flag);  
30. }  
31. return i;  
32. }  
33. }  

执行结果如下

1. finally coming when i=2 
2.  
3. finally coming when i=1 
4.  
5. 正常返回的结果b:2 
6.  
7. finally coming when i=3 
8.  
9. break返回的结果:3 
10.  
11. finally coming when i=4 
12.  
13. return返回的结果:-1 

结果说明无论上述什么情况，finally块总会被执行。

与其他语言的模型相比，finally 关键字是对 Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。 如果没有 finally，您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您必须如何编写代码来释放非内存资源：

1. import java.net.*;  
2. import java.io.*;  
3.  
4. class WithoutFinally  
5. {  
6. public void foo() throws IOException  
7. {  
8. //在任一个空闲的端口上创建一个套接字  
9. ServerSocket ss = new ServerSocket(0);  
10. try 
11. {  
12. Socket socket = ss.accept();  
13. //此处的其他代码...  
14. }  
15. catch (IOException e)  
16. {  
17. ss.close(); //1  
18. throw e;  
19. }  
20. //...  
21. ss.close(); //2  
22. }  
23. }  

这段代码创建了一个套接字，并调用 accept 方法。在退出该方法之前，您必须关闭此套接字，以避免资源漏洞。为了完成这一任务，我们在 //2 处调用 close，它是该方法的最后一条语句。但是，如果 try 块中发生一个异常会怎么样呢?在这种情况下，//2 处的 close 调用永远不会发生。因此，您必须捕获这个异常，并在重新发出这个异常之前在 //1 处插入对 close 的另一个调用。这样就可以确保在退出该方法之前关闭套接字。

这样编写代码既麻烦又易于出错，但在没有 finally 的情况下这是必不可少的。不幸的是，在没有 finally 机制的语言中，程序员就可能忘记以这种方式组织他们的代码，从而导致资源漏洞。Java 中的 finally 子句解决了这个问题。有了 finally，前面的代码就可以重写为以下的形式：

1. import java.net.*;  
2. import java.io.*;  
3.  
4. class WithFinally  
5. {  
6. public void foo2() throws IOException  
7. {  
8. //在任一个空闲的端口上创建一个套接字  
9. ServerSocket ss = new ServerSocket(0);  
10. try 
11. {  
12. Socket socket = ss.accept();  
13. //此处的其他代码...  
14. }  
15. finally 
16. {  
17. ss.close();  
18. }  
19. }  
20. }  

finally 块确保 close 方法总被执行，而不管 try 块内是否发出异常。因此，可以确保在退出该方法之前总会调用 close 方法。这样您就可以确信套接字被关闭并且您没有泄漏资源。在此方法中不需要再有一个 catch 块。在第一个示例中提供 catch 块只是为了关闭套接字，现在这是通过 finally 关闭的。如果您确实提供了一个 catch 块，则 finally 块中的代码在 catch 块完成以后执行。

finally 块必须与 try 或 try/catch 块配合使用。此外，不可能退出 try 块而不执行其 finally 块。如果 finally 块存在，则它总会执行。(无论从那点看，这个陈述都是正确的。有一种方法可以退出 try 块而不执行 finally 块。如果代码在 try 内部执行一条 System.exit(0); 语句，则应用程序终止而不会执行 finally 执行。另一方面，如果您在 try 块执行期间拨掉电源，finally 也不会执行。)