JAVA中的finally及异常丢失问题

在某些程序当中，我们通常会希望无论try块中的异常是否抛出，它们都能够得到执行。通常适用于内存回收之外的情况，为了达到此效果，可以在异常处理程序之后加入finally语句，finally子句总能够得到执行，看下面一段代码：

package access;
class ThreeException extends Exception{}
public class FinallyWorks {
	static int count = 0;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		while(true){
			try{
				if(count++ == 0)
					throw new ThreeException();
				System.out.println("No exception");
			}catch(ThreeException t){
				System.out.println("ThreeException");
			}finally{
				System.out.println("In finally clause");
				if(count == 2) break;
			}
		}
	}

}

此程序的输出结果为：

从输出结果中可以看到，finally子句始终被执行，当JAVA中的异常不允许我们返回到异常抛出点时，我们可以将try块放入while循环中，建立一个程序执行之前必须要达到的条件；还可以加入一个static计数器，使循环在放弃之前可以执行一定的次数。

JAVA有垃圾回收机制，内存释放不再是问题，JAVA也没有析构函数可以调用，finally的用处在于：将要把除内存之外的资源恢复到它们的初始状态时就需要用到finally子句，通常包括已经打开的文件或网络连接、在屏幕上画的某个图形、外部世界的某个开关。看下面一段代码：

package access;
import java.util.*;
public class Switch {
	private boolean state =  false;
	public boolean read(){
		return state;
	}
	public void on(){
		state = true;
		System.out.println(this);
	}
	public void off(){
		state = false;
		System.out.println(this);
	}
	public String toString(){
		return state?"on":"off";
	}
	class OnOffException1 extends Exception{}
	class OnOffException2 extends Exception{}
	private static Switch sw = new Switch();
	static void f() throws OnOffException1,OnOffException2{}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			sw.on();
			f();
			sw.off();
		}catch(OnOffException1 e){
			System.out.println("OnOffException1");
			sw.off();
		}catch(OnOffException2 e){
			System.out.println("OnOffException2");
			sw.off();
		}
	}

}

此程序的输出结果为：

程序的目的是确保main方法结束时开关必须是关着的，所以在catch中加入了sw.off()。但是也有可能发生异常被抛出却并没有被处理程序捕获的情况，这时sw.off()就得不到调用，所以加入finally来确保这种情况的不会发生：

package access;

import access.Switch.*;

public class WithFinally {
	static Switch sw = new Switch();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			sw.on();
			Switch.f();
		}catch(OnOffException1 e){
			System.out.println("OnOffException1");
		}catch(OnOffException2 e){
			System.out.println("OnOffException2");
		}finally{
			sw.off();
		}
	}

}

此程序的输出结果为：

在此种情况下，即使异常没有被当前的异常处理程序捕获，异常处理机制也会跳到高一层的异常处理程序之前执行finally子句。当涉及break和continue子句时，finally子句也同样会得到执行，如果把finally子句和带标签的break和continue子句配合使用的时候，就没必要使用goto子句了。

由于finally子句总是会执行，所以在一个方法中，可以从多点返回并且保证重要的清理工作的正常进行，看如下一段代码：

package access;
import java.util.*;
public class MultipleReturns {
	public static void f(int i){
		System.out.println("Initialization that requires cleanup");
		try{
			System.out.println("Point 1");
			if(i == 1)
				return;
			System.out.println("Point 2");
			if(i == 2)
				return;
			System.out.println("Point 3");
			if(i == 3)
				return;
			System.out.println("End");
			return;
		}finally{
			System.out.println("Performing cleanup");
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i = 1;i <= 4; i++)
			f(i);
	}

}

此程序的输出结果为：

从输出结果中可以看到，在finally内部，从何处返回并不重要。

另外，不带返回值的return语句只能用于返回类型为void类型的函数，作用是引起函数的强制结束，类似循环结构中的break语句。

尽管看上去JAVA的异常机制是如此合理，但依然有一些问题，最典型的就是异常丢失的问题。异常作为程序出错的标志，不应该被忽略任何一个，但是在某些情况下，它依然会被忽略掉，比如如下代码段：

package access;
class VeryImportantException extends Exception{
	public String toString(){
		return "A very important exception!";
	}
}
class HoHumException extends Exception{
	public String toString(){
		return "A trivial exception!";
	}
}
public class LostMessage {
	void f() throws VeryImportantException{
		throw new VeryImportantException();
	}
	void dispose() throws HoHumException{
		throw new HoHumException();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			LostMessage lm = new LostMessage();
			try{
				lm.f();
			}finally{
				lm.dispose();
			}
		}catch(Exception e){
			System.out.println(e);
		}
	}

}

此程序的输出结果为：

由输出可以看出，VeryImportantException被finally中的子句HoHumException取代，这是相当隐蔽并且微妙的丢失异常的缺陷。一直到现在的版本，JAVA仍然没有修复这个问题，而另一种更加简单的丢失异常的方式是从finally中返回，看如下代码：

package access;

public class ExceptionSilencer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			throw new RuntimeException();
		}finally{
			return;
		}
	}

}

此程序没有任何输出。修改程序：

package access;

public class ExceptionSilencer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			throw new RuntimeException();
		}catch(Exception e){
			System.out.println(e);
		}
	}

}

此程序的输出结果为：

对比两个程序可知即使抛出了异常，当在finally中使用return语句时异常仍然会丢失。