好久没写了，今天更新篇关于java的异常处理。
Java把异常当作对象来处理，并定义一个基类 作为所有异常的超类。
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
从图中可以看出所有异常类型都是内置类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
