异常处理

异常概述

指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建并抛出了一个异常对象。Java处理异常的方式是中断处理。
异常体系
异常机制其实是帮助我们找到程序中的问题，异常的根类是Throwable，其下有两个子类：Error类与Exception类，平常所说的异常指Exception

异常体系的特点
异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
异常的分类
我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。还有另外一种异常叫做运行时异常RuntimeException.

异常的产生过程解析
先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

class ArrayTools {
    //对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}
public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = {34, 12, 67};
        intnum = ArrayTools.getElement(arr, 4);
        System.out.println("num= "+num);
        System.out.println("over");
    }
}

上述程序执行过程图解：

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws
基本格式：

try { 
    可能出现异常的代码;
} catch(异常对象) { 
    异常处理代码; 
} finally { 
    释放资源;
}

变形格式：

• try…catch
• try…catch…catch…
• try…catch…catch…finally

①多个异常同时被捕获的时候，记住一个原则：先逮小后逮大
②通过在方法上声明，那么方法本身就不用解决，而由调用者解决，解决方式有两种：要么try…catch，要么抛。
③finally代码块：无论程序中是否有异常发生，并且无论try和catch是否顺利执行完毕，都会执行finally语句。
以下4种情况finally块不会被执行(面试题)：

1. 在finally语句中发生了异常
2. 在前面的代码中使用了System.exit(0);
3. 程序所在的线程全部死亡
4. 关闭CPU

异常处理的常用方法：

String toString()：获取异常名称
String getMessage()：获取异常信息
void printStackTrace()：打印异常的详细信息(异常类名和异常信息)

代码演示

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = {2, 4, 52, 2}; //创建一个数组 
        int index = 4; //根据索引找对应的元素 
        int element = getElement(arr, index);
        System.out.println(element);
        System.out.println("over");
    }
    public static int getElement(int[] arr,int index){ 
       	//判断索引是否越界
        if(index < 0 || index > arr.length-1){
             throw new ArrayIndexOutOfBoundsException("哥们，角标越界了.....");
        }
        int element = arr[index];
        return element;
    }
}

注意：如果产生了问题，我们就会throw将异常进行抛出，也就是将异常返回给该方法的调用者。那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续将异常抛出去，使用throws声明处理。

常见的异常类

异常名称	中文
ClassCastException	类型转换异常
ClassNotFoundException	类找不到异常
ArithmeticException	算术异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
SQLException	操作数据库异常
NullPointerException	空指针异常
NoSuchFieldException	字段未找到异常
NoSuchMethodException	方法未找到异常
NumberFormatException	数字格式化异常
StringOutOfBoundsException	字符串索引越界异常
IOException	输入输出异常
IllegalAccessException	访问权限异常
InstantistionException	指定类无法被实例化异常
FileNotFoundException	文件未找到异常

对多异常的处理
①声明异常时，建议声明更具体的异常，这样处理更为具体。
②声明几个异常就相应有几个catch块。不要定义多余的catch块。如果多个catch块出现继承关系，那么父类的catch块放在最下面(先逮小后逮大)。
在进行catch处理时，catch中一定要有具体的处理方式。

自定义异常

按照Java面向对象的思想，将程序中出现的特有问题进行封装。自定义异常类必须继承Exception或者RuntimeException

class MyException extends Exception {
    String name;
    MyException(String name) {
        this.name = name;
    }
}

继承Exception的原因：
因为异常类和异常对象都被抛出，具有可抛性，这个可抛性是throwable体系的独有特点。只有这个体系的类和对象才能被throw和throws操作。所以要先成为throwable体系中的一员，才能被throw和throws操作，那么就要继承Exception类或者RuntimeException类。当方法内部出现了throw抛出异常对象，那么就必须要给出对应的处理动作。
①要么在方法内部进行try…catch处理。
②要么在方法上声明让调用者处理。
一般情况下，方法内出现异常，方法上需要声明。
需求：在本程序中，对于除数是-1，也是错误的无法运算的。那么就要对该问题进行描述。

class FuShuException extends Exception {
    private String msg;
    private int value;
    FuShuException() {
       super();
    }
    FuShuException(String msg,int value) {
        super(msg);
        this.value = value;
    }
    public int getValue() {
       return value;
    }
}
class Test {
    public int method(int a,int b) throws FuShuException { //方法内抛出异常对象时，通过throws关键字需要在方法上声明
       if(b < 0)
          throw new FuShuException("by FuShu",b); //通过throw关键字抛出一个自定义异常对象。
      return a/b;
   }
}
public class MyException {
   public static void main(String[] args) {
       Test t = new Test();
       try {
           int x = t.method(4,-1);
       }catch(FuShuException e) {
           System.out.println(e.getMessage());
           System.out.println("ErrorValue:"+e.getValue());
       }
       System.out.println("over");
   }
}

throws和throw的区别？
①有throws的时候可以没有throw；有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
②throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类名，之间用逗号隔开；throw用于方法体中，其后跟的是一个异常对象名。

运行时异常

在Exception中有一个特殊的子类异常–运行时异常
特殊之处：
①如果在方法内抛出该异常，方法上可以不用声明，编译一样通过。
②如果方法上声明了该异常，调用者可以不进行处理，编译一样通过。
之所以不用在方法上声明，是不需要调用者处理。当RuntimeException异常发生时，希望程序停止，因为在运行时出现了无法运算的情况，希望停止程序后对代码进行修正。
常见的RuntimeExceprion异常：

异常名称	中文
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArithmeticException	算术异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
IllegalArgumentException	非法参数异常
SecurityException	安全性异常

异常在子父类覆盖中的体现
①子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常和该异常的子类。
②如果父类方法在抛出多个异常，那么子类在覆盖该方法时，只能抛出该异常的子类。
③如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，只能对其进行try…catch处理，绝对不能抛。