Java_5 异常

目录：

• 异常分类
• 声明及抛出
• 捕获异常
• 自定义异常
• 异常堆栈

---

---

异常指预期之外的各种状况。
异常处理，即增强程序的鲁棒性。
异常都是从throwable类派生出来的，而throwable类是直接从Object继承。

异常分类

• Error
  系统内部错误，系统自行处理，无需捕捉。
• Exception
  可以捕捉处理的异常。
  也是平时需要主要关注的异常。
  Exception 异常下主要有两大类：
  • 派生于 RuntimeException 的异常
    一般来说，RuntimeException都是程序员的问题。通常有以下几种：
    1.错误的数据类型转换；
    2.数组访问越界；
    3.算术异常；
    4.访问null指针。
  • 非 RuntimeException 异常（受查异常）
    一般有以下几类：
    1.打开了不存在的文档；
    2.未找到具体指定名称的类；
    3.操作文件异常。
• RuntimeException
  可以捕获，也可以不捕获的异常。
• 继承 Exception 的其它类
  必须捕获，通常在API文档中会说明这些方法会抛出哪些异常。

声明及抛出

• 抛出异常

// ThrowTest.java
// 抛出异常  throw new 异常名();
public class ThrowTest{

    public static void main(String[] args){
        Integer a = 1;
        Integer b = null;
        if (a == null || b == null){
            throw new NullPointerException();
        } else {
            System.out.println(a + b);
        }
    }
}

• 声明异常

// ThrowsTest.java
// throws
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowsTest{

    public static void main(String[] args) throws FileNotFoundException{
        throwsTest();
    }

    public static void throwsTest() throws FileNotFoundException{
        new FileInputStream("/home/project/shiyanlou.file");
    }
}

捕获异常

在处理异常时，并不要求完全匹配异常，子类也可以匹配父类。处理多个异常时，需要注意。

// MultipleCaptureDemo.java
// try .. catch .. finally
// 将可能发生错误的语句放在try语句块中，异常发生后要执行的语句放在catch语句块中，finally语句块中语句不论异常是否发生都会执行。
// 当程序中有多个异常时，可以通过catch来分别处理，但当前面的异常匹配后，后面的异常不再处理
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class MultipleCaptureDemo{
    public static void main(String[] args){
        try {
            new FileInputStream("");
        } catch (FileNotFoundException e){
            System.out.println("IO 异常");
        } catch (Exception e){
            System.out.println("异常");
        } finally {
            System.out.println("结束");
        }
    }
}

自定义异常

继承 Exception 或其子类即可。
建议同时提供无参和带字符串参数的构造方法，便于在调试时提供更详细的信息。

// MyAriException.java
public class MyAriException extends ArithmeticException{

    public MyAriException(){

    }

    public MyAriException(String msg){
        super(msg);
    }
}

// ExceptionTest.java
import java.util.Arrays;

public class ExceptionTest{
    public static void main(String[] args){
        int[] array = new int[5];
        Arrays.fill(array, 5);
        for (int i = 4; i > -1; i--){
            if (i == 0){
                throw new MyAriException("Exception occured.");
            } else {
                System.out.println("array[" + i + "] / " + i + " = " + array[i] / i);
            }
        }
    }
}

异常堆栈

异常抛出后，通过异常堆栈追踪程序的运行轨迹，以便更好的debug。

// ExceptionStackTrace.java
public class ExceptionStackTrace{
    private static void method(){
        method2();
    }

    private static void method2(){
        throw new NullPointerException();
    }

    public static void main(String[] args){
        try {
            method();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
/* *********************
java.lang.NullPointerException
        at ExceptionStackTrace.method2(ExceptionStackTrace.java:7)
        at ExceptionStackTrace.method(ExceptionStackTrace.java:3)
        at ExceptionStackTrace.main(ExceptionStackTrace.java:12)   

首先打印的是距离抛出异常最近的语句，然后是调用该方法的方法，然后是被调用的方法；
即自下而上的看，便是程序运行轨迹。
*/