Java---异常

异常

含义

异常是Java处理错误的一种机制，好的程序应该在异常发生的时候提供处理这些错误的方法，使得程序不会因为异常的发生而阻断。

程序错误处理方式

1. 传统方式：用if语句进行判断，并作相应的处理

2. 抛出异常（throw、throws），捕获异常（try…catch）的机制

异常处理机制

通常由这五个关键字来实现的：try，catch，finally，throw，throws

public void method(){
    try {
        可能产生异常的 代码段
    } catch (异常类型 e) {
        对异常进行处理的代码段
    }
    代码段
}

注：①try{}块表示受到监控的代码，如果发生异常，就会按照异常的种类，跳到对应的catch块中执行处理异常的代码段。
② e 是产生的异常对象的名字，异常发生时，都会有对应的异常对象，记录了异常的详细信息

异常体系

1.Throwable体系：
①Error：严重错误，无法通过处理的错误，只能事先避免。

②Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

2.Throwable中常用的方法
①printStackTrace()：打印异常的详细信息，包括异常的类型，异常的原因，还有异常出现的位置（主要用）。

②getMessage()：获取异常发生的原因

③toString()：获取异常的类型和异常描述信息（不用）

注：出现异常后，把异常的类名放在API中去查即可。

异常分类

1.编译时期异常（CheckedException）：如果有，则在编写代码的时候就会报错，必须要处理，一般使用try…catch代码块来解决或者throw来处理。
CheckedException的类型：
①IOException

②ClassNotFoundException

③FileNotFoundException

④ParseException

2.运行时期异常（RuntimeException）：编译的时候不报错，但是运行时会报错，通过判断就可以处理，一般不要求程序必须对他们进行处理。
RuntimeException的子类：
①ClassCastException（类型转换异常）:在多态中，可以使用Instanceof判断，进行规避。

②ArithmeticException（除零异常）：用if进行判断。

③NullPointerException（空指针异常）：用if进行判断。

④ArrayIndexOutOfBoundsException（数组越界异常）：使用数组的length属性，来进行避免。

注：
①遇到运行时异常无需进行处理，直接通过修改代码，来避免问题即可。

多重catch块

try {
   代码段
   产生异常(异常类型2)
} catch (异常类型1 e) {
   对异常进行处理的代码段
} catch (异常类型2 e) {
    对异常进行处理的代码段
} catch (异常类型3 e) {
    对异常进行处理的代码段
}

异常捕获应该由小到大进行处理

程序中的异常处理

1.自行处理：使用try…catch块，以保证程序正常运行

2.抛出异常：使用throws和throw向上抛出交由调用者处理

throw关键字的使用

1.手动抛出异常：意思是本方法不想处理异常，可以通过throw来告诉调用者当前的方法中报了什么异常，需要你做一个怎样的处理。

2.throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

3.使用格式：创建一个异常对象，封装一些提示信息（信息可以自己编写）。
throw new 异常类名（参数）

public class test {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        int index=4;
        int x=getIndex(arr,index);
        System.out.println(x);
    }

    public static int getIndex(int[] arr,int index){
        if(index<0||index>arr.length-1){
            //通知调用者应该传递过来什么样的数据
            //这个异常在编译时期不会报错，所以不必进行处理，调用这个方法时注意规则即可。
            throw new ArrayIndexOutOfBoundsException("索引已超出范围");
        }
        return index;
    }
}

声明异常throws

1.自动抛出异常：如果方法内使用throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者进行处理，因为抛出编译时异常，在编译的时候就会报错，必须处理。

2.throws放在方法声明之上，用于表示当前方法不处理异常，而是提醒方法的调用者来处理异常（抛出异常）

public class test {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        int index=4;
        int x= 0;
        try {
            x = getIndex(arr,index);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(x);
    }
}
    public static int getIndex(int[] arr,int index) throws ClassNotFoundException {
        if(index<0||index>arr.length-1){
            //通知调用者应该传递过来什么样的数据
            //这个异常在编译的时候就会报错，如果不进行捕获，就必须要使用throws向上抛出异常，交给调用者来处理
            throw new ClassNotFoundException("索引已超出范围");
        }
        return index;
    }

3.对于调用者来说如果不想处理，也可以使用throws再向上抛出，到main方法中就不能再抛出了，必须要使用try…catch进行异常捕获。

自定义异常

1.如何定义异常类：
①自定义一个编译期异常类：自定义类并继承于java.lang.Exception

public class MyException extends Exception{
        //定义本类无参构造
        public MyException(){

        }
        //定义本类有参构造
        public MyException(String message){
            //交给父类来做
            super(message);
        }
}

 public static void main(String[] args) {
      show();
 }
 public static void show(){
        try {
        //如果不捕获异常，就会一直报错，必须进行处理，还可以向上抛出
            throw new MyException("这是一个编译时期异常");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
    

②自定义一个运行时期的异常类：自定义类并继承于java.lang.RuntimeException

public class MyRuntimeException extends RuntimeException{
        //定义本类无参构造
        public MyRuntimeException(){

        }
        //定义本类有参构造
        public MyRuntimeException(String message){
            //交给父类来做
            super(message);
        }
}

 public static void main(String[] args) {
        MyRuntimeException m=new MyRuntimeException("这是一个运行时期异常");
        m.printStackTrace();
    }

finally关键字

定义：有一些特定的代码无论异常是否发生，都需要执行，还有因为异常会引发程序跳转，导致有些语句执行不到，finally就是解决这个问题的，在finally中存放的代码都是一定会被执行的。

注：
①有catch块的时候，异常外的代码可以正常执行，反之则不会执行，因为没有处理异常的能力。

②只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。