Java的异常捕获处理

异常处理机制

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的分支会导致程序的代码加长，可读性差。因此采用异常机制。

Java采用异常处理机制，将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁，并易于维护。

Java提供的是异常处理的抓抛模型。

Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。

异常对象的生成

由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。

由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。

如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

程序员通常只能处理Exception，而对Error无能为力。

捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。try/catch代码块中的代码称为保护代码。使用try/catch的语法如下：

try {
   // 程序代码
}catch(ExceptionName e) {
   //Catch 块
}
           

try

捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。

catch (Exceptiontype e)

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

如果明确知道产生的是何种异常，可以用该异常类作为catch的参数，也可以用其父类作为catch的参数。比如：可以用ArithmeticException类作为参数的地方，就可以用RuntimeException类作为参数，或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常，如NullPointerException（catch中的语句将不会执行）。

捕获异常的有关信息：与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

 getMessage()   获取异常信息，返回字符串

 printStackTrace()  获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第三个元素的时候就会抛出一个异常。

import java.io.*;
public class ExcepTest{
   public static void main(String args[]){
      try{
         // 可能产生异常的代码，即需要被检测的代码
         int a[] = new int[2];
         System.out.println("获取数组的第三个元素：" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){ // e用于接收try检测到的异常对象
         System.out.println("抛出的异常：" + e);
         System.out.println("message:"+e.getMessage()); // 获取的是异常的信息
         System.out.println("toString:"+e.toString()); // 获取的是异常的名字+异常的信息
         e.printStackTrace(); // 打印异常在堆栈中信息；异常名称+异常信息+异常的位置
      }
      System.out.println("try/catch代码块之后");
   }
}
           

执行结果为：

抛出的异常：java.lang.ArrayIndexOutOfBoundsException: 3
message:3
toString:java.lang.ArrayIndexOutOfBoundsException: 3
java.lang.ArrayIndexOutOfBoundsException: 3
	at ExcepTest.main(ExcepTest.java:6)
try/catch代码块之后
           

多重捕获块

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}
           

上面的代码段包含了 3 个 catch块。可以在 try 语句后面添加任意数量的 catch 块。

如果保护代码中发生异常，异常被抛给第一个 catch 块。如果抛出异常的数据类型与  异常类型1  匹配，它在这里就会被捕获。如果不匹配，它会被传递给第二个 catch 块。如此，直到异常被捕获或者通过所有的 catch 块。

try...catch...catch... 捕获异常时，大的异常(Exception类)放在下方，小的异常放在上方，否则，在异常捕获时，小的异常将不能被捕获，因为全在大的异常类中捕获到。即如果多个 catch 块中的异常出现继承关系，父类异常 catch 块放在最下面。

finally

finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{ 
  // 程序代码
}
           

捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。

不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。

finally主要用于关闭资源。无论是否发生异常，资源都必须进行关闭。只有在finally之前执行了System.exit(0); 从而退出jvm的这种情况下finally才不执行。

finally语句和catch语句是任选的。

import java.io.*;
public class ExcepTest{
   public static void main(String args[]){
      int a[] = new int[2]; 
      try{
         // 可能产生异常的代码，即需要被检测的代码
         System.out.println("获取数组的第三个元素：" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){ // e用于接收try检测到的异常对象
         System.out.println("抛出的异常：" + e);
      }finally{ // finally 关键字用来创建在 try 代码块后面执行的代码块。
         a[0] = 6;
         System.out.println("数组第一个元素的值：" +a[0]);
      }
   }
}
           

执行结果：

抛出的异常：java.lang.ArrayIndexOutOfBoundsException: 3
数组第一个元素的值：6
           

finally 代码块和 finalize()方法有什么区别？

无论是否抛出异常， finally 代码块都会执行，它主要是用来释放应用占用的资源。 finalize()方法是 Object 类的一个 protected 方法，它是在对象被垃圾回收之前由 Java 虚拟机来调用的。

使用异常捕获时注意下面几个事项：

1）catch 不能独立于 try 存在。

2）在 try/catch 后面添加 finally 块并非强制性要求的。

3）try 代码后不能既没 catch 块也没 finally 块。

4）try, catch, finally 块之间不能添加任何代码。

不捕获异常时的情况

前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过 ( 但运行时会发生异常使得程序运行终止 )。

如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常。

注意：    

1）异常处理完成以后，Exception对象会在下一个垃圾回收过程中被回收掉。

2）Java 语言定义了一些异常类在 java.lang 标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。