JAVA：异常处理

程序中的错误可以分为三类：

编译错误，逻辑错误和运行时错误

编译错误：是由于没有遵循Java语言的语法规则而产生的，这种错误要在编译阶段排除，否则程序不可能运行

逻辑错误：编译正常，也能运行，但结果不是人们期待的

运行时错误：运行过程中出现的错误，也有可能由逻辑错误引起

异常处理：主要目的是即使在程序运行时发生了错误，也要保证程序能正常结束，避免由于错误而使正在运行的程序中途停止

什么是异常？

• 一个好的应用程序，除了具备用户要求的功能外，还要求能预见程序执行过程中可能产生的各种异常，并把处理异常的功能包括在用户程序中
• 异常处理机制 是JAVA语言的重要特征之一，通过异常处理机制可防止执行期间因出现错误而造成不可预料的结果
• 异常是程序执行期间发生的各种意外或错误：

1. 用户输入错误
2. 内存不足
3. 算术运算错（数的溢出，除零操作）
4. 数组下标越界

 在JAVA程序运行过程中，产生的异常通常有三种类型：

1. JAVA虚拟机由于某些内部 错误产生的异常，这类异常不在用户程序控制之内，也不需要用户处理这类异常
2. 标准异常类，由JAVA系统预先定义好的。这类异常是由程序代码中的错误而产生的，如：除零操作，数组下标越界；这些需要用户程序处理的异常
3. 根据用户自定义的异常类

Java中所有的异常都用类表示，在JAVA中预定义了很多异常类，每个代表一种类型的运行错误。当程序发生异常，会生成某个异常类的对象

JAVA中标准异常类的层次结构

Java异常类都是系统类库中的Exception类的子类，他们分布在Java.lang  .Java.io    java.util    java.net包中，每个异常类对应特定的运行错误，各个异常类采用继承的方式进行组织。

异常举例：

  public static void main(String args[]){
        int arr[]=new int[2];
        for(int i=0;i<3;i++){
            arr[i]=i;

            System.out.println(arr[i]);
        }
    }

运行结果： 

0
1
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at tulun.Ex.main(Ex.java:7)

异常处理机制

JAVA对异常的处理涉及两个方面的内容：

一是抛出（throw）异常

二是捕捉（catch）异常

  如果程序在运行过程中出现了运行错误，并且产生的异常与系统中预定义某个异常类相对应，系统就自动产生一个该异常类的对象，这个过程称为抛出异常。当异常对象抛出时，将在程序中寻找处理这个异常的代码，如果找到处理代码，则把异常交给改代码段进行处理，这个过程称为捕捉异常。如果程序中没有给出处理异常的代码，则把异常交给Java运行系统默认的异常处理代码进行处理。默认的处理方式是：首先显示描述异常信息 的字符串，然后终止程序的运行。

异常抛出：

两种方式：系统自动抛出和利用抛出语句抛出

1.由系统自动抛出异常

     在程序运行过程中，如果出现了可被Java运行系统识别的错误，系统自动产生与该错误相对应的异常类的对象，即自动抛出异常，如上面的例子

2.人为异常抛出 

•  在方法头写出需要抛出的异常（利用throws语句）
• 在方法体内抛出异常（利用throw）

Throws语句抛出异常格式：

修饰符  返回值类型 方法名（[参数表]） throws 异常类1，异常类2{

           

....................

} 

例子：

public static void main(String args[])throws ArithmeticException,ArrayIndexOutOfBoundsException{
        {
            int a=4,b=0,c[]={1,2,3,4,5};
            System.out.println(a/b);
            System.out.println(c[a+1]);
            System.out.println("end");
        }

    }

结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at tulun.Ex.main(Ex.java:8)

 Throw语句抛出异常：

     如果需要在方法内某个位置抛出异常，可以使用Throw语句，通常将Throw语句与if语句配合使用

格式：

1.throw  异常类对象名

2.throw  （new 异常类名（））

说明：

执行throw语句时，程序终止执行后面的语句，在程序中寻找处理异常的代码；如果程序中没有给出处理代码，则把异常交给java运行系统处理

例1：

 public static void main(String args[]){
        ArithmeticException e=new ArithmeticException();
        int a=4,b=0;
        System.out.println("Before ArithmeticException  ");
        if(b==0) throw e;
        System.out.println(a/b);
    }

 

Exception in thread "main" java.lang.ArithmeticException
	at tulun.Ex.main(Ex.java:6)

 例2：

 public static void main(String args[]){
        int a=5,c[]={1,2,3,4,5};
        System.out.println("Before throw ArrayIndexOutOfBoundsException ");
        if(a>4) throw(new ArrayIndexOutOfBoundsException());
        System.out.println("After throw ArrayIndexOutOfBoundsException");
    }

 

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
Before throw ArrayIndexOutOfBoundsException   

例3：

public static void main(String args[]){
        int a=5,b=0,c[]={1,2,3,4,5};
        System.out.println("Before throw  ");
        if(b==0) throw (new ArithmeticException());
        System.out.println(a/b);
        if(a>4) throw(new ArrayIndexOutOfBoundsException());
        System.out.println(c[a]);
    }

Before throw  
Exception in thread "main" java.lang.ArithmeticException
	at tulun.Ex.main(Ex.java:8)

捕捉异常：

程序自己捕捉和处理异常，需要建立try---catch--finally语句块

 结构：

try{
        //发生的异常
    }
    catch(异常类1 e1){
        //处理异常 1；
    }
    ...
    catch(异常类n en){
        //处理异常 n；
    }
    finally{
        //不论异常是否发生，都要执行的部分；
    }

说明：

（1）将可能发生异常的程序代码放置在try程序中。如果该块内的代码出现了异常，系统将终止try块代码的执行，自动跳转到所发生的异常类对应的catch块中，执行该块中的代码。如果程序运行正常，后面的各个catch块不起任何作用

（2）final 块是个可选项，无论异常是否发生，finally块的代码必定执行。通常把对各种异常共同处理部分放在finally块中。如输出统一信息，释放资源，

（3）一个try可对应多个catch块，用于对多个异常类进行捕获。但最多只能选中一个执行

（4）异常对象与catch块中声明的实例的匹配原则：

    异常对象是catch块中声明的异常类的实例；

    异常对象是catch块中声明的异常类的某一个子类的实例；

例：

public static void main(String args[]) {
     int b=0,a;
     try{
         System.out.println("Before throw");
         a=5/b;
         System.out.println("the exception is throw,the statement is't run");
     }
     catch(ArithmeticException e){
         System.out.println("处理算数异常catch块的捕获");
         System.out.println("捕获的异常为"+e);
     }
     catch(ArrayIndexOutOfBoundsException e){
         System.out.println("处理下标越界 ");
         System.out.println("捕获的异常为"+e);
     }
     finally{
         System.out.println("try-catch-finally块");
     }
     System.out.println("最后的代码");



    }

Before throw
处理算数异常catch块的捕获
捕获的异常为java.lang.ArithmeticException: / by zero
try-catch-finally块
最后的代码

例2.

 public static void main(String args[]) {
     int a=5,b=0,c[]={1,2,3,4,5};
     try{
         System.out.println("Before throw");
         if(a>4) throw (new ArrayIndexOutOfBoundsException());
         System.out.println(c[a]);
         if(b==0) throw(new ArithmeticException());
         System.out.println(a/b);

         System.out.println("the exception is throw,the statement is't run");
     }
     catch(ArrayIndexOutOfBoundsException e){
         System.out.println("处理下标越界 ");
         System.out.println("捕获的异常为"+e);
         System.out.println(c[a]);
     }
     catch(ArithmeticException e){
         System.out.println("处理算数异常catch块的捕获");
         System.out.println("捕获的异常为"+e);
         System.out.println(a/b);
     }

     finally{
         System.out.println("try-catch-finally块");
     }
     System.out.println("最后的代码");



    }

处理下标越界 
捕获的异常为java.lang.ArrayIndexOutOfBoundsException
try-catch-finally块