java异常处理

java异常处理

异常基本知识：

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException的异常。

有些异常需要做处理，有些则不需要捕获处理。

Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。

    异常类有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

    异常的对象也有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。

异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。

通常，Java的异常分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。可查异常是编译器要求必须处置的异常。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。不可查异常是指编译器不要求强制处置的异常，包括运行时异常（RuntimeException与其子类）和错误（Error）。

    Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包含要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在对应异常的catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行，一般结构如下：

 try{

  程序代码

 }catch(异常类型1 异常的变量名1){

  程序代码

 }catch(异常类型2 异常的变量名2){

  程序代码

 }finally{

  程序代码

 }

    catch语句可以有多个，用来匹配多个异常，执行catch语句块仅仅执行匹配上的异常。catch的类型是Java语言中定义的或者程序员自己定义的，表示代码抛出异常的类型，异常的变量名表示抛出异常的对象的引用，如果catch捕获并匹配上了该异常，那么就可以直接用这个异常变量名，此时该异常变量名指向所匹配的异常，并且在catch代码块中可以直接引用。这一点非常非常的特殊和重要！

    Java异常处理的目的是提高程序的健壮性，你可以在catch和finally代码块中给程序一个修正机会，使得程序不因异常而终止或者流程发生以外的改变。同时，通过获取Java异常信息，也为程序的开发维护提供了方便，一般通过异常信息就很快就能找到出现异常的问题（代码）所在。

Java异常类类图

 

 

 

 

在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）。Throwable：有两个重要的子类：Exception（异常）和Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

    Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。Exception 类可以分为运行时异常和非运行时异常(编译异常)。

RuntimeException即运行时异常。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。对于运行时异常，程序可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常。一般情况下，不自定义运行时异常。

   异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

  

 

处理异常机制

在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。

   抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

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

由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。

对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。

对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。简单地说，异常总是先被抛出，后被捕捉的。

任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws语句。捕捉异常通过try-catch语句或者try-catch-finally语句实现。

总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

代码设计

对于可能出现异常的代码，有两种处理办法：

    第一、在方法中用try...catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。例如：

public void p(intx){

 try{

  ...

 }catch(Exception e){

  ...

 }finally{

  ...

 }

}

第二、对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常。抛出异常后可以选择捕获或者不捕获。例如：

public voidtest1() throws MyException{

 ...

 if(....){

  throw new MyException();

 }

}

    如果每个方法都是简单的抛出异常，那么在方法调用方法的多层嵌套调用中，Java虚拟机会从出现异常的方法代码块中往回找，直到找到处理该异常的代码块为止。然后将异常交给相应的catch语句处理。如果Java虚拟机追溯到方法调用栈最底部main()方法时，如果仍然没有找到处理异常的代码块，将按照下面的步骤处理：

    第一、调用异常的对象的printStackTrace()方法，打印方法调用栈的异常信息。

    第二、如果出现异常的线程为主线程，则整个程序运行终止；如果非主线程，则终止该线程，其他线程继续运行。

    越早处理异常消耗的资源和时间越小，产生影响的范围也越小。因此，不要把自己能处理的异常也抛给调用者。

     finally语句在任何情况下都必须执行的代码，这样可以保证一些在任何情况下都必须执行代码的可靠性。比如，在数据库查询异常的时候，应该释放JDBC连接等等。finally语句先于return语句执行，而不论其先后位置，也不管是否try块出现异常。finally语句块中不能通过给变量赋新值来改变return的返回值，也建议不要在finally块中使用return语句，没有意义还容易导致错误。在以下4种特殊情况下，finally块不会被执行：

1）在finally语句块中发生了异常。

2）在前面的代码中用了System.exit()退出程序。

3）程序所在的线程死亡。

4）关闭CPU。

注意事项：

   第一、try语句不能单独存在，可以和catch、finally组成 try...catch...finally、try...catch、try...finally三种结构，catch语句可以有一个或多个，finally语句最多一个，try、catch、finally这三个关键字均不能单独使用。

   第二、try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。

   第三、catch语句的匹配原则是，如果抛出的异常对象属于catch子句中描述的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。多个catch块时候，Java虚拟机只会匹配其中一个异常类或其子类，就执行这个catch块，然后catch语句就执行结束，无法再进行异常匹配。

第四、throw语句后不允许有紧跟其他语句，因为这些没有机会执行

第五、对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。例如RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在 最后面，否则可能会屏蔽其后的特定异常处理或引起编译错误。

    第六、如果一个方法调用了另外一个声明抛出异常的方法，那么这个方法要么处理异常，要么声明抛出。

    第七、throw和throws关键字区别：throw用来抛出一个异常，在方法体内。语法格式为：throw 异常对象。throws用来声明方法可能会抛出什么异常，在方法名后，语法格式为：throws 异常类型1，异常类型2...异常类型n。

   第八、可嵌套 try-catch-finally 结构，在 try-catch-finally 结构中，可重新抛出异常。

try，catch，finally语句块的执行

 

1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；

package chen;
 
importjava.io.IOException;
 
public classtest01{
       public static void main(String[] args) {
              int[] intArray = new int[3];
              try {
                     System.out.println(1/2);
                     System.out.println("上一条语句除数可能出现除数为零异常");
            System.out.println(intArray[1]);
            System.out.println("上一条语句可能数组越界");
              } catch(ArrayIndexOutOfBoundsException e) {
                     System.out.println("intArray数组下标越界异常。");
              } catch (ArithmeticException e) {
                     System.out.println("除数为0异常。");
              }
              finally{
              System.out.println("异常处理模块结束。");
              }
              System.out.println("程序结束");
       }
       }

结果如下：

 

2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；

package chen;
 
importjava.io.IOException;
 
public classtest01{
       public static void main(String[] args) {
              int[] intArray = new int[3];
              try {
                     System.out.println(1/0);
                     System.out.println("上一条语句除数可能出现除数为零异常");
            System.out.println(intArray[1]);
            System.out.println("上一条语句可能数组越界");
              } catch (ArrayIndexOutOfBoundsExceptione) {
                     System.out.println("intArray数组下标越界异常。");
              } /*catch (ArithmeticException e){
                     System.out.println("除数为0异常。");
              }*/
              finally{
              System.out.println("异常处理模块结束。");
              }
              System.out.println("程序结束");
       }
       }

运行结果：

 

3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

package chen;
 
importjava.io.IOException;
 
public class test01{
       public static void main(String[] args) {
              int[] intArray = new int[3];
              try {
                     System.out.println(1/0);
                     System.out.println("上一条语句除数可能出现除数为零异常");
            System.out.println(intArray[1]);
            System.out.println("上一条语句可能数组越界");
              } catch(ArrayIndexOutOfBoundsException e) {
                     System.out.println("intArray数组下标越界异常。");
              } catch (ArithmeticException e) {
                     System.out.println("除数为0异常。");
              }
              finally{
              System.out.println("异常处理模块结束。");
              }
              System.out.println("程序结束");
       }
       }
 

运行结果：

 

4）在catch语句块中出现新的异常：若新出现的异常被捕获，即在catch语句块中又有一个try-catch语句块形成嵌套结构，则里面的try-catch模块依然按照前三个规则进行，直至结束返回上一层嵌套，最后返回主程序执行。若新出现的异常未被捕获或者没有与之匹配的catch异常处理模块，则程序抛出异常，执行finally语句后，中断程序运行。finally语句后的程序无法得到运行。

package chen;
 
importjava.io.IOException;
 
public classtest01{
       public static void main(String[] args) {
              int[] intArray = new int[3];
              try {
                     System.out.println(1/0);
                     System.out.println("上一条语句除数可能出现除数为零异常");
            System.out.println(intArray[1]);
            System.out.println("上一条语句可能数组越界");
              } catch(ArrayIndexOutOfBoundsException e) {
                     System.out.println("intArray数组下标越界异常。");
              } catch (ArithmeticException e) {
                     System.out.println(intArray[5]);
              }
              finally{
              System.out.println("异常处理模块结束。");
              }
              System.out.println("程序结束");
       }
       }

运行结果：

 

Java常见异常

runtimeException子类:

java.lang.ArrayIndexOutOfBoundsException：数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

java.lang.ArithmeticException：算术条件异常。譬如：整数除零等。

java.lang.NullPointerException：空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等

java.lang.ClassNotFoundException：找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

java.lang.NegativeArraySizeException  数组长度为负异常

java.lang.ArrayStoreException数组中包含不兼容的值抛出的异常

java.lang.SecurityException安全性异常

java.lang.IllegalArgumentException非法参数异常

IOException子类

IOException：操作输入流和输出流时可能出现的异常。

EOFException   文件已结束异常

FileNotFoundException   文件未找到异常

其他

ClassCastException    类型转换异常类

ArrayStoreException  数组中包含不兼容的值抛出的异常

SQLException   操作数据库异常类

NoSuchFieldException   字段未找到异常

NoSuchMethodException   方法未找到抛出的异常

NumberFormatException    字符串转换为数字抛出的异常

StringIndexOutOfBoundsException字符串索引超出范围抛出的异常

IllegalAccessException  不允许访问某类异常

InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常