thinking-in-java(12)通过异常处理错误

【12.0】开场白

1）java的基本理念：结构不佳的代码不能运行；

2）改进的错误恢复机制：是提供代码健壮性的最强有力的方式；

3）java异常：

3.1）java采用异常来提供一致的错误报告模型，使得构件能够与客户端代码可靠沟通；

3.2）java异常的目的：简化大型，可靠程序的生成，确保你的应用中没有未处理的错误；

3.3）异常处理是java中唯一正式的错误报告机制：通过编译器强制执行；

【12.1】概念

1）异常的好处：能够降低错误处理代码的复杂度；

【12.2】基本异常

1）异常情形：是指阻止当前方法或作用域继续执行的问题；

2）异常处理程序：是将程序从错误状态中恢复，以使程序要么换一种方式运行，要么继续运行下去；

【12.2.1】异常参数

1）标准异常类有2个构造器：一个是默认构造器；另一个是接受字符串作为参数的构造器；

/*异常构造器的荔枝 */
public class ExceptionTest {
	public static void main(String[] args) {
		int flag = 1;
		
		if (flag == 1) {
			throw new NullPointerException("t = null");
		} else 
			throw new NullPointerException();
	}
}
/*
Exception in thread "main" java.lang.NullPointerException: t = null
	at chapter12.ExceptionTest.main(ExceptionTest.java:5)
*/

【代码解说】

1）把异常处理看做是一种返回机制： 因为可以用抛出异常的方式从当前作用域中退出；

2）Throwable是异常类型的基类：可以抛出任意类型的 Throwable对象；

【12.3】捕获异常

【12.3.1】try块

1）介绍：在try块中尝试各种方法调用；

【12.3.2】异常处理程序

1）catch块表示异常处理程序：在try块之后；

2）终止与恢复：

2.1）异常处理理论上有两种基本模型：终止模型 和 恢复模型；

2.2）程序员通常使用了 终止模型，而不怎么使用恢复模型；

【12.4】创建自定义异常

1）建立新异常类的最简单方法：让编译器为你产生默认构造器；这通过 继承 Exception 来实现；

/* 荔枝-自定义异常 */
class SimpleException extends Exception {} // 自定义异常

public class InheritingExceptions {
	public void f() throws SimpleException {
		System.out.println("Throw SimpleException from f()"); 
		throw new SimpleException();
	}

	public static void main(String[] args) {
		InheritingExceptions sed = new InheritingExceptions();
		try {
			sed.f(); // 1
		} catch (SimpleException e) {
			System.out.println("Caught it!"); // 2
		}
		System.out.println("continue."); //3, 恢复模型
	}
}
/*
Throw SimpleException from f()
Caught it!
continue.
*/

2）把错误信息发送给 标准错误流 System.err 比发给 标准输出流 System.out 要好：因为System.out 也许被重定向，而System.err 不会随System.out 一起被重定向；

/* 荔枝-错误信息被定向到标准输出流 System.out 还是 标准错误输出流System.err */
class MyException extends Exception {
	public MyException() {}
	public MyException(String msg) {
		super(msg);
	}
}
public class FullConstructors {
	public static void f() throws MyException {
		System.out.println("Throwing MyException from f()");
		throw new MyException();
	}

	public static void g() throws MyException {
		System.out.println("Throwing MyException from g()");
		throw new MyException("Originated in g()");
	}

	public static void main(String[] args) {
		try {
			f();
		} catch (MyException e) {
			// public final static PrintStream out = null;
			e.printStackTrace(System.out); // 重定向到 标准输出
		}
		try {
			g();
		} catch (MyException e) {
			// public final static PrintStream err = null;
			e.printStackTrace(System.err); // 重定向到 标准错误输出
			e.printStackTrace(); // (同上)重定向到 标准错误输出（默认）
		}
	}
}  
/*
Throwing MyException from f()
chapter12.MyException
	at chapter12.FullConstructors.f(FullConstructors.java:17)
	at chapter12.FullConstructors.main(FullConstructors.java:27)
Throwing MyException from g()
chapter12.MyException: Originated in g()
	at chapter12.FullConstructors.g(FullConstructors.java:22)
	at chapter12.FullConstructors.main(FullConstructors.java:32)
*/

【代码解说】

1）printStackTrace()方法：打印 “从方法调用处到抛出异常处” 的方法调用序列栈；

2）printStackTrace() 默认输出流：标准错误输出流；

【12.4.1】异常与记录日志

【荔枝-异常与记录日志 】

/* 荔枝-异常与记录日志 */
class LoggingException extends Exception { // 自定义异常类型
	private static Logger logger = Logger.getLogger("LoggingException");
	public LoggingException() {
		StringWriter trace = new StringWriter();
		// step2, 6
		printStackTrace(new PrintWriter(trace)); // 打印异常信息，即打印方法调用序列（从方法调用处到抛异常处）到 StringWriter 输出流；
		// step3, 7
		logger.severe(trace.toString()); // 严重日志：调用与日志级别相关联的方法。（日志级别为严重 severe）
	}
}
public class LoggingExceptions {
	public static void main(String[] args) throws InterruptedException {
		try {
			System.out.println("抛出第一个异常"); // step1
			throw new LoggingException();
		} catch (LoggingException e) {
			System.err.println("Caught " + e); // step4
		}
		try {
			Thread.sleep(1000);
			System.out.println("抛出第二个异常"); // step5
			throw new LoggingException();
		} catch (LoggingException e) {
			System.err.println("Caught " + e); // step8
		}
	}
}  
/*
抛出第一个异常
十一月 27, 2017 11:49:38 上午 chapter12.LoggingException <init> // 日志 
严重: chapter12.LoggingException // 日志 
	at chapter12.LoggingExceptions.main(LoggingExceptions.java:18) // 方法调用处到抛出异常处的方法调用栈

Caught chapter12.LoggingException // // 异常类的toString 方法
抛出第二个异常
十一月 27, 2017 11:49:39 上午 chapter12.LoggingException <init> // 日志 
严重: chapter12.LoggingException // 日志 
	at chapter12.LoggingExceptions.main(LoggingExceptions.java:25) // 方法调用处到抛出异常处的方法调用栈

Caught chapter12.LoggingException // 异常类的toString 方法
*/

1）通常情况：需要捕获和记录其他人编写的异常，这就必须在异常处理程序中生成日志；

/* 荔枝-在异常处理程序中生成日志 */
public class LoggingExceptions2 {
	private static Logger logger = Logger.getLogger("LoggingExceptions2");
	
	static void logException(Exception e) {
		StringWriter trace = new StringWriter();
		logger.severe(trace.toString());
	}
	public static void main(String[] args) {
		try {
			throw new NullPointerException();
		} catch (NullPointerException e) {
			// 需要捕获和记录其他人编写的异常，这就必须在异常处理程序中生成日志；
			logException(e); 
		}
	}
} 
/*
十一月 28, 2016 2:09:22 下午 chapter12.LoggingExceptions2 logException
严重: 
*/

2）进一步自定义异常：如加入额外的构造器和成员；

// 自定义新异常，添加了字段x 以及设定x值的 构造器和 读取数据的方法.
class MyException2 extends Exception {
	private int x;
	
	public MyException2() {}
	public MyException2(String msg) {  super(msg); }
	public MyException2(String msg, int x) { //额外的构造器 和 成员
		super(msg);
		this.x = x;
	}
	public int val() { return x; }
	// 还覆盖了 Throwable.getMessage() 方法, 以产生更详细的信息.
	@Override
	public String getMessage() { 
		return "Detail Message: " + x + " " + super.getMessage();
	}
}
public class ExtraFeatures {
	public static void f() throws MyException2 {
		print("Throwing MyException2 from f()");
		throw new MyException2();
	}
	public static void g() throws MyException2 {
		print("Throwing MyException2 from g()");
		throw new MyException2("Originated in g()"); //额外的构造器
	}
	public static void h() throws MyException2 {
		print("Throwing MyException2 from h()");
		throw new MyException2("Originated in h()", 47); //额外的构造器
	}
	public static void main(String[] args) {
		try {
			f();
		} catch (MyException2 e) {
			e.printStackTrace(System.out);
		}
		try {
			g();
		} catch (MyException2 e) {
			e.printStackTrace(System.out);
		}
		try {
			h();
		} catch (MyException2 e) {
			e.printStackTrace(System.out);
			System.out.println("e.val() = " + e.val());
		}
	}
}  
/*
Throwing MyException2 from f()
chapter12.MyException2: Detail Message: 0 null
	at chapter12.ExtraFeatures.f(ExtraFeatures.java:20)
	at chapter12.ExtraFeatures.main(ExtraFeatures.java:32)
Throwing MyException2 from g()
chapter12.MyException2: Detail Message: 0 Originated in g()
	at chapter12.ExtraFeatures.g(ExtraFeatures.java:24)
	at chapter12.ExtraFeatures.main(ExtraFeatures.java:37)
Throwing MyException2 from h()
chapter12.MyException2: Detail Message: 47 Originated in h()
	at chapter12.ExtraFeatures.h(ExtraFeatures.java:28)
	at chapter12.ExtraFeatures.main(ExtraFeatures.java:42)
e.val() = 47
*/

【代码解说】

1）自定义新异常，添加了字段x 以及设定x值的 构造器和 读取数据的方法；

2）覆盖了 Throwable.getMessage()方法，以产生更详细的信息；（对于异常类来说，getMessage()方法类似于 toString()方法）；

【12.5】异常说明

1）异常说明：java鼓励程序员把方法可能抛出的异常告知调用该方法的程序员，这是优雅的做法；以异常说明的形式进行告知；

2）异常说明：属于方法声明，在形式参数列表之后；

3）异常说明：使用了 throws 关键字，后面跟潜在潜在异常类型列表，方法定义如下：

void f() throws Exception1, Exception2, Exception3, ... {

4）如果抛出异常而没有进行处理：编译器提醒，要么处理这个异常，要么在异常说明中表明该方法将产生异常； （这是在编译的时候作出的提醒，所以这种异常称为编译时异常）

5）【编码技巧】作弊：声明抛出异常但是实际却没有抛出。好处是，为异常先占个位置，以后抛出这种异常就不用修改已有代码。在定义抽象基类和接口时这种能力很重要的，

这样派生类或接口实现类就能够抛出这些预先声明的异常；（不能再干货）

6）被检查的异常（编译时异常）：这种在编译时被强制检查的异常；

【12.6】捕获所有异常

1）通过捕获异常类型的基类 Exception 捕获所有异常；通常把 捕获Exception 的 catch 子句放在处理程序列表（catch块列表）末尾，避免它抢在其他处理程序前被捕获了；

2）public class Exception extends Throwable，Exception常用的方法列表：

getMessage()：获取详细信息；
getLocalizedMessage()：获取本地语言表示的详细信息；
toString()

3）打印Throwable 的调用栈轨迹（抛出异常处到方法调用处）：

printStackTrace(); 输出到标准错误输出流；
printStackTrace(PrintStream);
printStackTrace(java.io.PrintWriter);

4）Throwable fillStackTrace()：在Throwable对象内部记录栈帧的当前状态。这在程序重新抛出异常或错误非常有用；

5）Throwable继承自Object的其他方法：

getClass()：返回对象类型的对象；
getClass().getName()：返回对象信息名称；
getClass().getSimpleName()：

【荔枝-如何使用Exception的方法】

// Exception 基类 Throwable 的方法列表.
public class ExceptionMethods {
	public static void main(String[] args) {
		try {
			throw new Exception("My Exception");
		} catch (Exception e) {
			print("Caught Exception");
			print("getMessage(): " + e.getMessage()); // getMessage():My Exception
			print("getLocalizedMessage(): " + e.getLocalizedMessage()); // getLocalizedMessage():My Exception
			print("toString(): " + e); // toString():java.lang.Exception: My Exception
			print("printStackTrace(): ");
			e.printStackTrace(System.out); // 打印抛出异常栈轨迹元素， 打印的信息通过 getStackTrace() 来直接获取；
		}
	}
}  
/*
Caught Exception
getMessage():My Exception
getLocalizedMessage():My Exception
toString():java.lang.Exception: My Exception
printStackTrace():
java.lang.Exception: My Exception
	at chapter12.ExceptionMethods.main(ExceptionMethods.java:8)
*/ 

【代码解说】每个方法都比前一个方法打印出更多的信息，因为每一个都是前一个的超集；

【12.6.1】栈轨迹

1）栈轨迹：通过 printStackTrace()方法打印，打印的信息通过 getStackTrace() 来直接获取；

2）getStackTrace()：该方法返回一个由栈轨迹中的元素所构成的数组 ；

// 荔枝-获取调用栈轨迹数组-getStackTrace()
public class WhoCalled {
	static void f() {
		try {
			throw new Exception();
		} catch (Exception e) {
			// getStackTrace() 返回 栈轨迹的元素组成的数组
			for (StackTraceElement ste : e.getStackTrace())
				System.out.println(ste.getMethodName()); // 异常抛出地点的方法调用.
		}
	}
	static void g() {
		f();
	}
	static void h() {
		g();
	}
	public static void main(String[] args) {
		f();
		System.out.println("--------------------------------");
		g(); // g() -> f()
		System.out.println("--------------------------------");
		h(); // h() -> g() -> f()
	}
} 
/*
f
main
-------------------------------- 调用栈轨迹（先进后出）： f() -> g() -> main， main() 最先调用, f() 最后调用
f
g
main
--------------------------------
f
g
h
main
*/

【12.6.2】重新抛出异常：分为重新抛出同一种类型的异常 还是 抛出另外一种类型的异常

1）重新抛出异常语法：

catch(Exception e) {

throw e;

}

2）重新抛出异常：会把异常抛给上一级环境的异常处理程序， 同一个try块的后续catch子句被会略；

3）重新抛出异常-fillInStackTrace()：printStackTrace() 打印的是原来异常的调用栈信息，而不是新的异常抛出处的调用栈信息；fillInStackTrace() 返回一个Throwable对象，会把当前调用栈填入原来异常对象；

【荔枝-重新抛出异常】

// fillInStackTrace()  那一行成了异常的新发生地.
public class Rethrowing {
	public static void f() throws Exception {
		System.out.println("originating the exception in f()");
		throw new Exception("thrown from f()");
	}
	public static void g() throws Exception {
		try {
			f(); 
		} catch (Exception e) {
			System.out.println("Inside g(),e.printStackTrace()");
			e.printStackTrace(System.out); // 打印抛出异常栈轨迹元素， 打印的信息通过 getStackTrace() 来直接获取；
			throw e;
		}
	}
	public static void h() throws Exception {
		try {
			f();
		} catch (Exception e) {
			System.out.println("Inside h(),e.printStackTrace()");
			e.printStackTrace(System.out);
			// fillInStackTrace()  那一行成了异常的新发生地.
			// 调用 fillInStackTrace()方法后，轨迹栈 是 main()->h()，而不是main() ->h() -> f()
			throw (Exception) e.fillInStackTrace(); 
		}
	}
	public static void main(String[] args) {
		try {
			g(); // g() -> f()
		} catch (Exception e) {
			System.out.println("main: printStackTrace()");
			e.printStackTrace(System.out); // 打印抛出异常栈轨迹元素， 打印的信息通过 getStackTrace() 来直接获取；
		}
		System.out.println("\n\n main 方法中的 第二个 异常抛出， fillInStackTrace() 测试");
		try {
			h(); // h() -> f()
		} catch (Exception e) {
			System.out.println("main: printStackTrace()2");
			e.printStackTrace(System.out);
		}
	}
}  
/*
originating the exception in f()
Inside g(),e.printStackTrace()
java.lang.Exception: thrown from f()
	at chapter12.Rethrowing.f(Rethrowing.java:6)
	at chapter12.Rethrowing.g(Rethrowing.java:10)
	at chapter12.Rethrowing.main(Rethrowing.java:28)
main: printStackTrace()
java.lang.Exception: thrown from f()
	at chapter12.Rethrowing.f(Rethrowing.java:6)
	at chapter12.Rethrowing.g(Rethrowing.java:10)
	at chapter12.Rethrowing.main(Rethrowing.java:28)


 main 方法中的 第二个 异常抛出
originating the exception in f()
Inside h(),e.printStackTrace()
java.lang.Exception: thrown from f()
	at chapter12.Rethrowing.f(Rethrowing.java:6)
	at chapter12.Rethrowing.h(Rethrowing.java:19)
	at chapter12.Rethrowing.main(Rethrowing.java:35)
main: printStackTrace()
java.lang.Exception: thrown from f()
	at chapter12.Rethrowing.h(Rethrowing.java:23)
	at chapter12.Rethrowing.main(Rethrowing.java:35)
*/

【荔枝-重新抛出一种新异常】

// 荔枝-重新抛出一个新异常(捕获 OneException异常后， 抛出 TwoException 异常.)
class OneException extends Exception {
	public OneException(String s) {
		super(s);
	}
}
class TwoException extends Exception {
	public TwoException(String s) {
		super(s);
	}
}
public class RethrowNew {
	public static void f() throws OneException {
		System.out.println("originating the exception in f()");
		throw new OneException("thrown from f()");
	}
	public static void main(String[] args) {
		try {
			try {
				f();
			} catch (OneException e) {
				System.out.println("Caught in inner try, e.printStackTrace()");
				e.printStackTrace(System.out);
				// 在捕获异常后 抛出另外一种异常
				// 捕获 OneException异常后， 抛出 TwoException 异常.
				throw new TwoException("from inner try");
			}
		} catch (TwoException e) {
			System.out.println("Caught in outer try, e.printStackTrace()");
			e.printStackTrace(System.out); // 最外层的try-catch捕获的异常的调用栈信息 没有 f()方法调用
		}
	}
}  
/*
originating the exception in f()
Caught in inner try, e.printStackTrace()
chapter12.OneException: thrown from f()
	at chapter12.RethrowNew.f(RethrowNew.java:16)
	at chapter12.RethrowNew.main(RethrowNew.java:21)
Caught in outer try, e.printStackTrace()
chapter12.TwoException: from inner try
	at chapter12.RethrowNew.main(RethrowNew.java:25)
*/

【代码解说】 最外层的catch子句打印的调用栈信息只包含 main() 方法，不包含 f()方法的调用栈信息；

【12.6.3】异常链

1）异常链：常常需要在捕获第一个异常后抛出第二个异常，但想保留第一个异常的信息， 这被称为异常链；

2）三种基本的异常构造器提供了 cause 参数， 该参数吧原始异常（第一个异常）传递给第二个异常（新异常）；

分别是Error，Exception 和 RuntimeException；

3）使用 ininCause() 方法可以把其他异常链连起来，

【荔枝-使用 ininCause() 方法可以把其他异常链连起来】

// 荔枝-通过initCause() 方法把 NullPointerException 插入到 DynamicFieldsException异常链中.
class DynamicFieldsException extends Exception {}

public class DynamicFields {
	private Object[][] fields;
	public DynamicFields(int initialSize) {
		fields = new Object[initialSize][2];
		for (int i = 0; i < initialSize; i++)
			fields[i] = new Object[] { null, null };
	}
	public String toString() {
		StringBuilder result = new StringBuilder();
		for (Object[] obj : fields) {
			result.append(obj[0]);
			result.append(": ");
			result.append(obj[1]);
			result.append("\n");
		}
		return result.toString();
	}

	private int hasField(String id) { 
		for (int i = 0; i < fields.length; i++)
			if (id.equals(fields[i][0]))
				return i;
		return -1;
	}

	private int getFieldNumber(String id) throws NoSuchFieldException {
		int fieldNum = hasField(id);
		if (fieldNum == -1)
			throw new NoSuchFieldException();
		return fieldNum;
	}

	private int makeField(String id) {
		for (int i = 0; i < fields.length; i++)
			if (fields[i][0] == null) {
				fields[i][0] = id;
				return i;
			}
		// No empty fields. Add one:
		Object[][] tmp = new Object[fields.length + 1][2];
		for (int i = 0; i < fields.length; i++)
			tmp[i] = fields[i];
		for (int i = fields.length; i < tmp.length; i++)
			tmp[i] = new Object[] { null, null };
		fields = tmp;
		// Recursive call with expanded fields:
		return makeField(id);
	}

	public Object getField(String id) throws NoSuchFieldException {
		return fields[getFieldNumber(id)][1];
	}
	// 其他方法都可以忽略不看，看 这个方法setField() 即可。
	public Object setField(String id, Object value)
			throws DynamicFieldsException {
		if (value == null) {
			// Most exceptions don't have a "cause" constructor.
			// In these cases you must use initCause(),
			// available in all Throwable subclasses.
			DynamicFieldsException dfe = new DynamicFieldsException();
			// initCause() 方法把 NullPointerException 插入到 DynamicFieldsException异常链中.
			dfe.initCause(new NullPointerException());
			throw dfe; // 如果value=null，抛出异常
		}
		int fieldNumber = hasField(id);
		if (fieldNumber == -1)
			fieldNumber = makeField(id);
		Object result = null;
		try {
			result = getField(id); // Get old value
		} catch (NoSuchFieldException e) {
			// Use constructor that takes "cause":
			throw new RuntimeException(e);
		}
		fields[fieldNumber][1] = value;
		return result;
	}

	public static void main(String[] args) {
		DynamicFields df = new DynamicFields(3);
		print("df = { " + df + " }");
		try {
			df.setField("d", "A value for d");
			df.setField("number", 47);
			df.setField("number2", 48);
			print("df = { " + df + " }");
			
			df.setField("d", "A new value for d");
			df.setField("number3", 11);
			print("df = { " + df + " }");
			
			print("df.getField(\"d\") = " + df.getField("d"));
			
			Object field = df.setField("d", null); // 把value设置为null，故意让setField()方法抛出异常
		} catch (NoSuchFieldException e) {
			e.printStackTrace(System.out);
		} catch (DynamicFieldsException e) {
			e.printStackTrace(System.out);
		}
	}
} 
/*
Object field = df.setField("d", null); // 仅仅打印这句代码抛出的异常信息， 该代码把value设置为null，故意让setField()方法抛出异常
chapter12.DynamicFieldsException
	at chapter12.DynamicFields.setField(DynamicFields.java:66)
	at chapter12.DynamicFields.main(DynamicFields.java:100)
Caused by: java.lang.NullPointerException // 通过initCause() 方法把 NullPointerException 插入到 DynamicFieldsException异常链中.
	at chapter12.DynamicFields.setField(DynamicFields.java:68)
	... 1 more
*/ 

【12.7】Java标准异常

1）异常基类：Throwable；有两个子类，包括 Error 和 Exception；

1.1）Error：表示编译时和系统错误；（程序员不用关心）

1.2）Exception：用于方法和运行时可能抛出的异常类型；（关心）；

【荔枝-Throwable, Exception, RuntimeException, Error, 源码】

public class Throwable implements Serializable {
public class Error extends Throwable {
public class Exception extends Throwable {
public class RuntimeException extends Exception {

【12.7.1】特例： RuntimeException-运行时异常

1）属于运行时异常的类型有很多：自动被jvm抛出，无需程序员抛出（但还是可以在代码中抛出 RuntimeException异常）；因为运行时异常太多了，如果都去捕获的话，代码显得混乱；

2）不受检查的异常：运行时异常RuntimeException 也被称为 不受检查的异常；这种异常属于错误，被自动捕获；

【荔枝-显式抛出运行时异常】

// 荔枝-显式抛出运行时异常
public class NeverCaught {
	static void f() {
		throw new RuntimeException("From f()"); // 3-抛出异常
	}
	static void g() { 
		f(); // 2
	}
	public static void main(String[] args) {
		g(); // 1 
	}
}  
/*
Exception in thread "main" java.lang.RuntimeException: From f()
	at chapter12.NeverCaught.f(NeverCaught.java:6)
	at chapter12.NeverCaught.g(NeverCaught.java:9)
	at chapter12.NeverCaught.main(NeverCaught.java:12)
*/

【注意】只能在代码中忽略 RuntimeException 及其子类的异常， 其他类型异常的处理都是由编译器强制实施的。

RuntimeException代表的是编程错误；

无法预料的错误；

应该在代码中进行检查的错误；

【12.8】使用 finally 进行清理

1）finally块： 无论try块中的异常是否抛出，finally 块的内容始终执行；

【荔枝-finally块】

// finally 的经典荔枝
class ThreeException extends Exception {}
public class FinallyWorks {
	static int count = 0;
	public static void main(String[] args) {
		// 循环了两次，第一次抛出异常，第二次没有抛出异常，并在finally块中结束
		while (true) {
			try {
				if (count++ == 0)
					throw new ThreeException();
				System.out.println("No exception"); // 3

			} catch (ThreeException e) {
				System.out.println("ThreeException"); // 1
			} finally {
				System.out.println("In finally clause"); // 2, 4
				if (count == 2)
					break; 
			}
		}
	}
}
/*
ThreeException
In finally clause
No exception
In finally clause
*/

【编程技巧】当java中的异常不允许程序回到异常抛出处，应该如何应对？ 把try块放在 循环里。（参考ThreeException.java 荔枝）

【12.8.1】finally 用来做什么？

1）finally块：保证 无论try块发生了什么，内存总能得到释放；

2）finally的用处：当把除内存之外的资源恢复到初始状态时，需要用到 finally块；

【荔枝- 内部finally 先于外部catch() 子句执行】

// 荔枝- 内部finally 先于外部catch() 子句执行。
// 无论try块中是否抛出异常， finally语句块被执行.
public class AlwaysFinally {
	public static void main(String[] args) {
		print("Entering first try block, 1"); // 1
		try {
			print("Entering second try block, 2"); // 2
			try {
				throw new FourException();
				// java异常不允许我们回到 异常抛出地点， 
				// 故， 内部finally 先于外部catch() 子句执行.
			} finally { // 内部finally
				print("finally in 2nd try block, 3"); // 3
			}
		} catch (FourException e) { //　外部catch
			System.out.println("Caught FourException in 1st try block, 4"); // 4
		} finally {
			System.out.println("finally in 1st try block, 5"); // 5
		}
	}
}  
/*
Entering first try block, 1
Entering second try block, 2
finally in 2nd try block, 3
Caught FourException in 1st try block, 4
finally in 1st try block, 5
*/

【12.8.2】在return中使用finally：

1）return 返回前会执行finally子句或finally块中的内容；

// 荔枝-在return使用finally子句 
public class MultipleReturns {
	public static void f(int i) {
		print("\n=== Initialization that requires cleanup, point = " + i);
		try {
			print("Point 1");
			if (i == 1)
				return;
			print("Point 2");
			if (i == 2)
				return;
			print("Point 3");
			if (i == 3)
				return;
			print("End");
			return;
			// finally 子句总是会执行.
		} finally {
			print("Performing cleanup in finally clause.");
		}
	}
	public static void main(String[] args) {
		for (int i = 1; i <= 4; i++)
			f(i);
	}
} 
/*
=== Initialization that requires cleanup, point = 1
Point 1
Performing cleanup in finally clause.

=== Initialization that requires cleanup, point = 2
Point 1
Point 2
Performing cleanup in finally clause.

=== Initialization that requires cleanup, point = 3
Point 1
Point 2
Point 3
Performing cleanup in finally clause.

=== Initialization that requires cleanup, point = 4
Point 1
Point 2
Point 3
End
Performing cleanup in finally clause.
*/

【12.8.3】缺憾：异常丢失

【荔枝】异常丢失的荔枝

// 异常丢失的荔枝
class VeryImportantException extends Exception {
	public String toString() {
		return "A very important exception from VeryImportantException!";
	}
}
class HoHumException extends Exception {
	public String toString() {
		return "A trivial exception from HoHumException!";
	}
}
public class LostMessage {
	void throwVeryImportantException() throws VeryImportantException {
		throw new VeryImportantException();
	}
	void throwHoHumException() throws HoHumException {
		throw new HoHumException();
	}
	public static void main(String[] args) {
		try {
			LostMessage lm = new LostMessage();
			try {
				lm.throwVeryImportantException();  // 抛出  VeryImportantException 异常
				// 先执行内部finally子句
			} finally { 
				lm.throwHoHumException(); // 抛出  HoHumException 异常
			}
		// 后执行外部 catch 子句
		} catch (Exception e) { 
			System.out.println(e);
		}
	}
} 
/*
A trivial exception from HoHumException!  结果抛出了 HoHumException 异常， VeryImportantException 异常被覆盖了。
*/

【代码解说】VeryImportantException 异常被 finally 子句里的 HoHumException 所取代， 抛出的VeryImportantException异常丢失了；

【荔枝】异常丢失的荔枝2

// 异常丢失荔枝2
// 从finally 子句中返回，如果运行这个程序，即使抛出了异常，也不会产生任何输出；
public class ExceptionSilencer {
	public static void main(String[] args) {
		try {
			throw new RuntimeException();
		} finally {
			return; // 从finally 子句中返回
		}
	}
} 
/*
不会产生任何输出
 */ 

【编码技巧】使用finally 要防止出现 异常丢失的情况；

【12.9】异常限制

1）当子类覆盖父类方法时：只能抛出基类方法的异常说明里列出的异常；

【编码技巧】异常限制对构造器不起作用，派生类构造器不能捕获基类构造器抛出的异常；

// BaseballException异常父类
class BaseballException extends Exception {} // BaseballException-棒球
class Foul extends BaseballException {} // Foul-犯规
class Strike extends BaseballException {} // Strike-击打 

// Inning-（棒球）一局
abstract class Inning { 
	public Inning() throws BaseballException, NullPointerException {} // 构造器抛异常
	public void event() throws BaseballException {} // event-事件
	public abstract void atBat() throws Strike, Foul; // atBat-在球棒上
	public void walk() {} // walk-行走
}
class StormException extends Exception {} // StormException-暴风雨异常
class RainedOut extends StormException {} // RainedOut- 因雨取消
class PopFoul extends Foul {} // PopFoul-流行犯规 

interface Storm {
	public void event() throws RainedOut;
	public void rainHard() throws RainedOut;
}
public class StormyInning extends Inning implements Storm { // StormyInning-暴风雨中的一局棒球赛 
	public StormyInning() throws RainedOut, BaseballException {} // 构造器抛出异常，派生类构造器抛出的异常不受父类构造器抛出异常的限制
	public StormyInning(String s) throws Foul, BaseballException {} // 构造器抛出异常
	public void rainHard() throws RainedOut {} // rainHard-下大雨
	public void event() {}
	public void atBat() throws PopFoul {}

	public static void main(String[] args) {
		try {
			StormyInning si = new StormyInning(); // 新建子类对象
			si.atBat();
		} catch (PopFoul e) {	
			System.out.println("Pop foul");
		} catch (RainedOut e) {
			System.out.println("Rained out");
		} catch (BaseballException e) {
			System.out.println("Generic baseball exception");
		} catch(Exception e) {
			System.out.println("Generic Exception");
		}
		try {
			Inning i = new StormyInning(); // 父类指针指向子类对象
			i.atBat();
		} catch (Strike e) {
			System.out.println("Strike");
		} catch (Foul e) {
			System.out.println("Foul");
		} catch (RainedOut e) {
			System.out.println("Rained out");
		} catch (BaseballException e) {
			System.out.println("Generic baseball exception");
		}
	}
} // 打印结果 为空

【代码解说】 Inning 是父类， StormyInning 是子类，而子类 StormyInning 抛出的异常不受父类 Inning 抛出异常的限制；如下：

public Inning() throws BaseballException, NullPointerException {} // 父类构造器抛异常；
public class StormyInning extends Inning implements Storm {
	public StormyInning() throws RainedOut, BaseballException {} // 派生类构造器抛出的异常不受父类构造器抛出异常的限制；
	public StormyInning(String s) throws Foul, BaseballException {} // 派生类构造器抛出的异常不受父类构造器抛出异常的限制；
	// ......
}

【12.10】构造器

1）问题： 如果异常发生，所有东西都能够被清理吗？ 当涉及到构造器时， 问题就出现了，即便finally 也不能完全解决。

2）如果在构造器内抛出异常，清理行为就不能正常工作了。所以 编写构造器时要格外小心；

3）如果构造器（如创建文件输入流）在其执行过程中半途而废（文件路径找不到，输入流创建失败），也许该对象还没有被成功创建，而这些部分在 finally 子句中却要被清理； （这容易触发空指针异常）

【荔枝-finally块 关闭了没有打开的文件输入流，抛出空指针异常的处理方法】

// 荔枝-如何处理finally块中抛出异常的情况
public class InputFile {
	private BufferedReader in;

	public InputFile(String fname) throws Exception {
		try {
			in = new BufferedReader(new FileReader(fname));
		} catch (FileNotFoundException e) {
			System.out.println("Could not open " + fname);
			throw e;
		} catch (Exception e) {
			try {
				in.close(); // close()方法也可能 抛出异常
			} catch (IOException e2) {
				System.out.println("in.close() unsuccessful");
			}
			throw e; // Rethrow
		} finally {
			// Don't close it here!!!
		}
	}
	public String getLine() {
		String s;
		try {
			s = in.readLine();
		} catch (IOException e) {
			throw new RuntimeException("readLine() failed");
		}
		return s;
	}
	// dispose-处理处置安排：关闭文件输入流
	public void dispose() {
		try {
			in.close();
			System.out.println("dispose() successful");
		} catch (IOException e2) {
			throw new RuntimeException("in.close() failed");
		}
	}
} 
// 在构造阶段可能抛出异常， 并且要求清理的类，使用到了 嵌套try 子句
public class Cleanup {
	static String path = System.getProperty("user.dir") 
			+ File.separator  + "src" + File.separator + "chapter12" + File.separator;
	// 用二层 try-catch
	public static void main1(String[] args) {
		try { // 外层try-catch
			InputFile in = null;
			try { // 双层 try语句块(嵌套try子句)
				in = new InputFile(path + "erroPath" + "Cleanup.java"); // 错误路径
				String s;
				int i = 1;
				while ((s = in.getLine()) != null);
			} catch (Exception e) {
				System.out.println("Caught Exception in main");
				e.printStackTrace(System.out);
			} finally {
				in.dispose(); // 关闭文件输入流
			}
		} catch (Exception e) {
			System.out.println("InputFile construction failed");
		}
		System.out.println("continue;"); // 即便抛出异常，还是继续执行；
	}
	/* 第一个main() 打印结果
	Could not open D:\classical_books\thinking-in-java\AThinkingInJava\src\chapter12\erroPathCleanup.java
	Caught Exception in main
	java.io.FileNotFoundException: D:\classical_books\thinking-in-java\AThinkingInJava\src\chapter12\erroPathCleanup.java (系统找不到指定的文件。)
		at java.io.FileInputStream.open0(Native Method)
		at java.io.FileInputStream.open(FileInputStream.java:195)
		at java.io.FileInputStream.<init>(FileInputStream.java:138)
		at java.io.FileInputStream.<init>(FileInputStream.java:93)
		at java.io.FileReader.<init>(FileReader.java:58)
		at chapter12.InputFile.<init>(InputFile.java:11)
		at chapter12.Cleanup.main(Cleanup.java:14)
	InputFile construction failed
	continue;
	 */
	// 用一层 try-catch
	public static void main(String[] args) {		
		InputFile in = null;
		
		try { // 双层 try语句块(嵌套try子句)
			in = new InputFile(path + "erroPath" + "Cleanup.java"); // 错误路径
			String s;
			int i = 1;
			while ((s = in.getLine()) != null);
		} catch (Exception e) {
			System.out.println("Caught Exception in main");
			e.printStackTrace(System.out);
		} finally {
			// 关闭文件输入流(如果文件路径错误或其他错误导致文件输入流没有打开的话，in为null，会抛出空指针异常)
			in.dispose(); 
		}
		System.out.println("continue;"); // 如果抛出异常，程序执行终止，这句无法执行；
	}  
}
/* 第二个main() 打印结果
Could not open D:\classical_books\thinking-in-java\AThinkingInJava\src\chapter12\erroPathCleanup.java
Caught Exception in main
java.io.FileNotFoundException: D:\classical_books\thinking-in-java\AThinkingInJava\src\chapter12\erroPathCleanup.java (系统找不到指定的文件。)
	at java.io.FileInputStream.open0(Native Method)
	at java.io.FileInputStream.open(FileInputStream.java:195)
	at java.io.FileInputStream.<init>(FileInputStream.java:138)
	at java.io.FileInputStream.<init>(FileInputStream.java:93)
	at java.io.FileReader.<init>(FileReader.java:58)
	at chapter12.InputFile.<init>(InputFile.java:11)
	at chapter12.Cleanup.main(Cleanup.java:48)
Exception in thread "main" java.lang.NullPointerException
	at chapter12.Cleanup.main(Cleanup.java:57)
*/

【代码解说】

解说1）如果FileReader 构造器失败，抛出 FileNotFoundException 异常。对于这种异常，不需要关闭文件，因为这个文件还没有打开。
然而，任何其他捕获异常的catch 子句必须关闭文件，因为捕获异常时，文件已经打开了。所以 这里就矛盾了。
解说2）所以finally块中的 in.dispose() 可能抛出异常；所以还需要再封装一层 try-catch （双层try-catch）；
解说3）getLine()方法将异常转换为 RuntimeException， 表示这是一个编程错误；
解说4）最安全的使用方式：使用嵌套的try子句，就如 上面的 Cleanup.java 荔枝；

【编码技巧】在创建需要清理的对象后，立即进入一个 try-finally 语句块：

【荔枝-在创建需要清理的对象后，立即进入一个 try-finally 语句块】

class NeedsCleanup {  
	private static long counter = 1;
	private final long id = counter++;
	public void dispose() { // 清理内存 或 关闭输入李 或 其他清理操作
		System.out.println("NeedsCleanup " + id + " disposed");
	}
}
class ConstructionException extends Exception {}
class NeedsCleanup2 extends NeedsCleanup {
	public NeedsCleanup2() throws ConstructionException {} // 构造器抛出异常
}

// 在创建需要清理的对象后，立即进入一个 try-finally 语句块.
public class CleanupIdiom {
	public static void main(String[] args) {
		// Section 1:
		NeedsCleanup nc1 = new NeedsCleanup();
		try {
			// ...
		} finally {
			nc1.dispose(); // // 清理内存 或 关闭输入李 或 其他清理操作
		}
		// Section 2:
		// If construction cannot fail you can group objects:
		NeedsCleanup nc2 = new NeedsCleanup();
		NeedsCleanup nc3 = new NeedsCleanup();
		// 在创建需要清理的对象后，立即进入一个 try-finally 语句块.
		try { 
			// ...
		} finally {
			nc3.dispose(); // 清理内存 或 关闭输入李 或 其他清理操作
			nc2.dispose(); // 清理内存 或 关闭输入李 或 其他清理操作
		}
		// Section 3: 展示了如何处理那些具有可以失败的构造器，且需要清理的对象。（处理方法是 3层try-catch块 ）
		// If construction can fail you must guard each one:
		try {
			NeedsCleanup2 nc4 = new NeedsCleanup2();
			try {
				NeedsCleanup2 nc5 = new NeedsCleanup2();
				// 在创建需要清理的对象后，立即进入一个 try-finally 语句块.
				try {
					// ...
				} finally {
					nc5.dispose(); // 清理内存 或 关闭输入李 或 其他清理操作
				}
			} catch (ConstructionException e) { // nc5 constructor
				System.out.println(e);
			} finally {
				nc4.dispose();
			}
		} catch (ConstructionException e) { // nc4 constructor
			System.out.println(e);
		}
	}
}  
/*
NeedsCleanup 1 disposed
NeedsCleanup 3 disposed
NeedsCleanup 2 disposed
NeedsCleanup 5 disposed
NeedsCleanup 4 disposed
*/

【代码解说】

1）Section 3 展示了如何处理那些具有可以失败的构造器，且需要清理的对象。

2）处理方法是 3层try-catch块：对于每一个构造，都必须包含在 try-finally 块中，并且每一个对象构造都必须跟随一个 try-finally 块以确保清理；

【12.11】异常匹配

1）异常处理系统找到代码书写顺序最近的异常进行处理，且不再继续查找；

【荔枝-异常匹配】

// 异常匹配的荔枝
class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

public class Human {
	public static void main(String[] args) {
		// Catch the exact type:
		try {
			throw new Sneeze(); // 抛出子类异常
		} catch (Sneeze s) { // 捕获子类异常
			System.out.println("Caught Sneeze");
		} catch (Annoyance a) { // 捕获基类异常
			System.out.println("Caught Annoyance 1");
		}
		// Catch the base type:
		try {
			throw new Sneeze(); // 抛出子类异常
		} catch (Annoyance a) {  捕获基类异常
			System.out.println("Caught Annoyance 2"); // 这里捕获异常
		}
	}
}  
/*
Caught Sneeze
Caught Annoyance 2
*/

【代码解说】 catch (Annoyance a) 会捕获Annoyance 及其子类的异常；

2）如果把捕获基类异常的catch子句放在最前面，则会把后面子类的异常捕获子句 catch 子句 屏蔽掉，如：

try{
	throw new Sneeze(); // 抛出子类异常
} catch (Annoyance a) { // // 捕获基类异常
	System.out.println("Caught Annoyance 1"); // 这里捕获异常
} catch (Sneeze s) { //  捕获子类异常
	System.out.println("Caught Sneeze"); // 异常捕获子句被屏蔽
} 

3）编译器报错：编译器会发现 catch (Sneeze s) 永远不会执行，编译器报错；

【12.12】其他可选方式

1）异常处理的目标：把错误处理的代码和错误发生的地点相分离；