TIJ学习笔记-异常

java异常

参考博客：http://www.cnblogs.com/focusj/archive/2011/12/26/2301524.html

http://tech.ccidnet.com/art/3737/20030721/468063_1.html

1. 什么是异常：

阻止当前方法或作用域继续执行的问题。

2.  异常分类

Throwable是一切异常或错误的根类。一切皆可抛。

Error和Exception是Throwable是的两个子类。

Error:应用程序不应试图捕获的严重问题[编译时和系统错误]。交由jvm处理。

Exception:可以被抛出的基本类型。它分为两类CheckedException和UncheckedException.

CheckedException需要用try catch显示的捕获。

UncheckedException不需要显示的捕获。

对于可恢复的条件使用CheckedException.对于程序错误，使用UncheckedException(又叫RuntimeException).

3. 常见RuntimeException

NullPointerException:空指针异常。

NumberFormatException：继承IllegalArgumentException。

ArrayIndexOutOfBoundsException:数组越界

StringIndexOutOfBoundsException：字符串越界

ClassCastException:类型转换错误

ArithmeticException：算术错误，典型的就是0作为除数的时候。

IllegalArgumentException：非法参数，在把字符串转换成数字的时候经常出现的一个异常。

4.  异常链

捕获一个异常后，在抛出另一个异常，并且把原始异常信息保存下来。被称为异常链。用initCause()方法链接其它类型异常。

package com.zhiru;
/*
 * 异常丢失
 * 异常链：用initCause()构造异常链.
 */
class ExceptionA extends Exception{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public ExceptionA(){
		super();
	}
}
class ExceptionB extends Exception{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public ExceptionB(String str){
		super(str);
	}
}
class ExceptionC extends Exception{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public ExceptionC(String s){
		super(s);
	}
}
public class MyException {

	public static void f1() throws ExceptionB{
		throw new ExceptionB("ExceptionB throws");
	}
	public static void f2() throws ExceptionC{
		try{
			f1();
		} catch(ExceptionB e){
			ExceptionC c=new ExceptionC("ExcptionC throwed");
			c.initCause(e);//构造异常链
			throw c;
		}
	}
	public static void main(String[]args){
		try{
			f2();
		} catch(ExceptionC e){
			e.printStackTrace();
		}
	}
}
/*
 * com.zhiru.ExceptionC: ExcptionC throwed
	at com.zhiru.MyException.f2(MyException.java:42)
	at com.zhiru.MyException.main(MyException.java:48)
*/
/*
 * com.zhiru.ExceptionC: ExcptionC throwed
	at com.zhiru.MyException.f2(MyException.java:45)
	at com.zhiru.MyException.main(MyException.java:52)
Caused by: com.zhiru.ExceptionB: ExceptionB throws
	at com.zhiru.MyException.f1(MyException.java:39)
	at com.zhiru.MyException.f2(MyException.java:43)
	... 1 more

 * 
 * */

5.  finally

无论try中抛出什么异常，finally中的子句总能被执行。

把除内存之外的资源恢复到它们的初始状态时，使用finally子句.

package com.zhiru;

public class ExceptionSilencer {

	@SuppressWarnings("finally")
	public static void f(int i) {
		try {
			System.out.println("intering...");
			System.out.println(1);
			if (i == 1)
				return;
			System.out.println(2);
			if (i == 2)
				return;
			System.out.println(3);
			if (i == 3)
				return;
			System.out.println("end");
			return;
		} finally {
			return;
			// System.out.println("clean up");

		}
	}

	 public static void main(String[] args) {
	 // TODO Auto-generated method stub
	 // try{
	 // throw new RuntimeException();
	 // }
	 // finally{
	 // return;//在子句中返回，即使抛出异常，但不会输出。
	 // }
	 for(int i=1;i<=4;i++)
	 f(i);
	
	 }

}
/*
 * intering...
1
intering...
1
2
intering...
1
2
3
intering...
1
2
3
end*/

6.  return中的finally

应为finally子句总会执行，所以在类内，从何处return无关紧要。

7.  异常丢失

class A extends Exception{

public String toString(){

return “A catch”;

}

}

class B extends Exception{

public String toString(){

return “B catch”;

}

}

public class LostException{

void f() throws A{

throw new A();

}

void g() throws B{

throw new B();

}

main(){

try{

LostException le=new LostException();

try{

le.f();

}finally{

le.g();

}

}catch(Exception e){

System.out.println(e);

}

}

}

输出：B catch

8. 构造器中的清理

在构造器中可能抛出异常的类，清理工作要利用嵌套的try子句。

try{

//…

try{

//…

}catch(Exception e){

}finally{

//清理工作

}

}catch(Exception e){

}

9. 抛出异常后发生了什么

1）    在堆上创建异常对象

2）    当前执行终止，并弹出异常对象的引用

3）    异常处理程序接管程序，并寻找异常处理程序继续执行程序。