java日常记录9-- 异常-摩杜云开发者社区

好久没写了，今天更新篇关于java的异常处理。

Java把异常当作对象来处理，并定义一个基类作为所有异常的超类。

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

java日常记录9-- 异常_System

从图中可以看出所有异常类型都是内置类Throwable因而Throwable在异常类的层次结构的顶层。

Error类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常），该类型的异常自动为你所编写的程序定义
NullPointerException （空指针异常）、
ArrayIndexOutOfBoundsException（数组下标越界）、NullPointerException （空指针异常）、ArithmeticException（算术异常）等。

Java异常处理机制
1、抛出异常
首先要明白什么是异常情形（exception condition），它是指阻止当前方法或作用域继续执行的问题。其次把异常情形和普通问题相区分，普通问题是指在当前环境下能得到足够的信息，总能处理这个错误。

if(stu == null){
throw
} new NullPointerException();

2、捕获异常
在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

注意：
对于运行时异常、错误和检查异常，Java技术所要求的异常处理方式有所不同
由于运行时异常及其子类的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。

对于所有的检查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉检查异常时，它必须声明将抛出异常。

3、异常处理五个关键字

try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
ﬁnally –
ﬁnally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有ﬁnally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果ﬁnally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
throw – 用于抛出异常。
throws – 用在方法签名中，用于声明该方法可能抛出的异常。

处理异常
try - catch

try{
//code that might generate exceptions
}catch(Exception e){
//the code of handling exception1
}catch(Exception e){
//the code of handling exception2
}

public class TestException {
	public static void main(String[] args) {
		int a = 1;
		int b = 0;
		try { // try监控区域
			if (b == 0) throw new 	ArithmeticException(); // 通过throw语句抛出异常
			System.out.println("a/b的值是：" + a / b);
			System.out.println("this will not be printed!");
	}
		catch (ArithmeticException e) { // catch捕捉异常
			System.out.println("程序出现异常，变量b不能为0！");
	}
		System.out.println("程序正常结束。");
	}
}

//输出程序出现异常，变量b不能为0！程序正常结束。

thorw
throw语句抛出明确的异常。

throw ThrowableInstance;

class TestThrow{
		static void proc(){
		try{
		throw new NullPointerException("demo");
		}catch(NullPointerException e){
		System.out.println("Caught inside proc");
		throw e;
		}
	}
	
	public static void main(String [] args){
		try{
			proc();
		}catch(NullPointerException e){
			System.out.println("Recaught: "+e);
			}
		}
	}

throws
如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己
而不发生异常。要做到这点，我们可以在方法声明中包含一个 throws子句。

public void info() throws Exception
{
//body of method
}

class TestThrows{
	static void throw1() throws IllegalAccessException {
		System.out.println("Inside throw1 . ");
	throw new IllegalAccessException("demo");
}
public static void main(String[] args){
	try {
		throw1();
		}catch(IllegalAccessException e ){
	System.out.println("Caught " + e); 
			}
		}
	}

ﬁnally
当异常发生时，通常方法的执行将做一个陡峭的非线性的转向，它甚至会过早的导致方法返回。例如，如果一个方法打开了一个文件并关闭，然后退出，你不希望关闭文件的代码被异常处理机制旁路。
finally关键字为处理这种意外而设计。
finally 创建的代码块在try/catch 块完成之后另一个 try/catch 出现之前执行。
finally 块无论有没有异常抛出都会执行。如果抛出异常，即使没有 catch 子句匹配，
finally 也会执行。
finally后接一定会执行的语句

class TestFinally{
	 static void proc1(){
	try{
		System.out.println("inside proc1"); throw new RuntimeException("demo");
		}finally{
			System.out.println("proc1's finally");
		}
}
	static void proc2(){
	 try{
		System.out.println("inside proc2");
		return ;	
	} finally{
		System.out.println("proc2's finally");
	}
}
static void proc3(){
 try{
	System.out.println("inside proc3");
	}finally{
		System.out.println("proc3's finally");
	}
}
public static void main(String [] args){ 
	try{
		proc1();
		}catch(Exception e){ 	
			System.out.println("Exception caught");
	}
	proc2();
	proc3();
}

try, catch,ﬁnally ,return 执行顺序
1.执行try，catch ，给返回值赋值
2.执行ﬁnally
3．return