java异常捕获、异常处理、异常调用栈

package cm;

import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.IIOException;
import javax.management.RuntimeMBeanException;

import cm.P;
//1.大多数异常都存在于java.lang包中
//2.nullpointerexception异常表示在堆栈上声明了一个应用，但是没有将引用指定到具体的对象。
//3.runtimeexception 运行时期的异常，方法不需要进行异常说明。
//4.当涉及到break和continue的时候，finally子句也会的到执行。
//5.一般像文件开关等操作都需要自己手动开启和关闭，垃圾回收器不能帮助你回收。
//6.bufferedreader.getLine()方法返回下一行的内容，此方法调用了能抛出异常readline()方法，并且让异常在readline（）方法内部处理了，getline（）方法因此不会抛出异常了
//getline（）将异常转换成一个runtimeexception，表示一个编程错误。
//7.一场匹配，当抛出异常的时候，异常处理系统会按照你书写代码的顺序查找异常处理代码，就近查找，一旦找到一个处理程序，就不再进行查找了。

public class test20180405 {
	// today we test java how to deal with Exception
	public static void main(String[] args) throws Throwable {// Throwable可以作为任何异常抛出的类，分为两种，一种error表示编译器和系统错误，而exception表示程序中常犯的错误
		simpleexception sm = new simpleexception();
		// int []x=new int[3];
		// try {
		// System.out.println(x[5]);
		// } catch (Exception e) {
		// P.sopl("goto catch statement");
		// e.printStackTrace();//printStackTrace打印出程序出错的位置及原因，打印出错误栈中的内容此方法是在Throwable类中声明的
		// }

		// P.sopl("--------------------------------------------------自定义异常构造器并调用");
		// try {
		// simpleexception sm = new simpleexception();// 类中没有定义构造器，调用基类的构造器
		// sm.f();// 这个方法返回一个异常对象
		// } catch (simpleexception e) {//这里可以替换成基类中的一个Exception，这样catch就能捕获全部的异常。
		// P.sopl("caught it");
		// P.sopl(e.toString());//返回Throwable的简单描述。
		// P.sopl(e.getMessage());//返回异常对象中的字符串信息
		// P.sopl(e.getLocalizedMessage());
		// e.printStackTrace();//返回异常对象调用的顺序位置。返回的异常信息最全。
		// }

		// P.sopl("--------------------------------------------------测试异常对象发生地点信息变化");
		// try {
		// simpleexception sm=new simpleexception();
		// sm.g();
		// } catch (Exception e) {
		// P.sopl("in method main()");
		// e.printStackTrace();//
		// }
		// P.sopl("--------------------------------------------------测试runtimeexception");
		// sm.c();

		// P.sopl("--------------------------------------------------被检查的异常（exception）包装进未被检查的异常（runtimeexception）");
		wrapcheckexception wr = new wrapcheckexception();
		// wr.throwruntimeexception(0);//因为被检测的exception异常被包装进了未被检查的异常runtiemexception所以不需要使用trycatch来捕获异常和处理
		for (int i = 0; i < 4; i++) {
			try {// 有了trycatch语句之后，程序抛出异常，得到恰当处理，程序得以继续执行，否则将会终止程序。
				if (i < 3) {
					wr.throwruntimeexception(i);
				} else {
					throw new SomeOtherException();
				}
			} catch (SomeOtherException e) {
				P.sopl("SomeOtherException" + e);
			} catch (RuntimeException e) {
				try {
					throw e.getCause();
				} catch (FileNotFoundException a) {
					P.sopl("FileNotFoundException:" + a);
				} catch (IOException a) {
					P.sopl("IOException:" + a);
				} catch (Throwable a) {
					P.sopl("Throwable:" + a);// runtimeexception和exception都是继承的throwable类
				}
			}
		}
	}
}

class simpleexception extends Exception {
	private static final long serialVersionUID = 1L;

	public void f() throws simpleexception {// 一个方法要跑出异常对象需要在方法后throw异常对象，这告诉客户端程序员此方法将抛出什么类型的异常对象
		// 如果一个方法可能抛出多个异常，则方法后的throws的异常类型用逗号分隔开。
		P.sopl("Throw simpleexception for f()");
		throw new simpleexception();// 我们在这里可以throw一个异常对象，只是在方法声明处说明会返回一个异常，这样可以为方法提前占有一个返回异常对象的位置。

	}

	public void g() throws Throwable {
		try {
			f();
		} catch (simpleexception e) {
			P.sopl("in method g()");
			e.printStackTrace();
			throw e.fillInStackTrace();// 此方法返回一个Trowable类型的异常对象，并调用当前调用栈信息填入对象
		}
	}

	public void c() {
		throw new RuntimeException();
	}
}

class wrapcheckexception {
	void throwruntimeexception(int type) {
		try {
			switch (type) {// case后边都需要跟一个break或者continue但是在trycatch中不能，因为跟了break或者bontinue就直接跳出switch了，不会执行到catch语句
			case 0:
				throw new FileNotFoundException();
			case 1:
				throw new IOException();
			case 2:
				throw new RuntimeException("where am i");
			default:
				break;
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

class SomeOtherException extends Exception {
}