异常

异常概念
异常，就是不正常的意思。在生活中：医生说你的身体某个部位有异常，该部位和正常相比有点不同该部位的功能将受影响在程序中的意思就是：

• 异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
  在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误语法错了，编译不通过不会产生字节码文件根本不能运行

异常体系

异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,其下有两个子类java.lang.Error与java.lang.Exception,平常所说的异常指java.lang.Exception。

Throwable体系:

• Error：严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。

• Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。
  Throwable中的常用方法：

• public void printstackTrace()：打印异常的详细信息
  包含了异常的类型异常的原因还包括异常出现的位置在开发和调试阶段都得使用 printStackTrace

• public String getMessage():获取发生异常的原因。

异常分类

java.lang.Throwable：类是Java语言中所有错误或异常的超类。

我们平常说的异常就是指 Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序

异常（Exception）的分类：根据在编译时期还是运行时期去检查异常？

• 编译时期异常：checked异常。在编译时期，就会检查如果没有处理异常，则编译失败。（如日期格式化异常）
• 运行时期异常：runtime异常。在运行时期检查异常在编译时期运行异常不会编译器检测（不报错）。（如数学异常）
  
  例如：

public class Demo01Exception {
    public static void main(String[] args) throws ParseException {
        //编译时期异常
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date date=sdf.parse("1999-09-09");
        System.out.println(date);
        //两种方式：一种是抛出去，另一种是try...catch处理
        try {
            Date date2=sdf.parse("1999-09-09");
        }catch (ParseException x){
            System.out.println("异常的后续操作");
        }

        int []arr={1,2,3};
        //编译不报错，但是执行会报错
        //int num=arr[3];

        try{
            int num=arr[3];
        }catch (Exception e){
            System.out.println("异常的后续操作");
        }

        //运行出现错误
        // java.lang.OutOfMemoryError: Java heap space
        //内存溢出错误，创建的数组太大，超出了JVM分配的内存
        int [] arr2=new int[1024*1024*1024];

        System.out.println(arr2);
    }
}

异常的产生过程解析

public class Demo02Exception {
    public static void main(String[] args) {
        int[] arr ={1,2,3};
        int e=getElement(arr,3);
        System.out.println(e);
    }
    public static int getElement(int[] arr,int index){
        int ele=arr[index];
        return ele;
    }
}

原理：

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

抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1. 创建一个异常对象。封装一些提示信息（信息可以自己编写）
2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字 throw就可以完成。throw异常对象

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

• throw关键字必须写在方法的内部
• throw关键字后边new的对象必须是 Exception或者 Exception的子类对象
• throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
• throw关键字后边创建的是 RuntimeException或者是 RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）
• throw关键字后边创建的是编译异常（写代码的时候报错）我们就必须处理这个异常，要么 throws，要么try…catch
  作用：可以使用throw关键字在指定的方法中抛出指定的异常
  使用格式：

throw new 异常类名("参数(异常产生原因)");

例如：

public class Demo03Throw {
    /*
    定义一个方法，获取数组指定索引处的元素
    参数：
         int[]arr
         int index
    以后（工作中）我们首先必须对方法传递过来的参数进行合法性校验
    如果参数不合法，那么我们就必须使用抛出昇常的方式，告知方法的调用者，传递的参数有问题
    注意：
        NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理
     */
    public static void main(String[] args) {
//        int[] arr=null;
//        int e=getElement(arr,0);
//        System.out.println(e);
        //Exception in thread "main" java.lang.NullPointerException: 传递的数组是空
        int[] arr2=new int[3];
        int e2=getElement(arr2,3); 
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的索引超岀了数组的使用范围
        System.out.println(e2);
    }

    public static int getElement(int[] arr,int index){
        /*
        我们可以对传递过来的参数数组进行合法性校验
        如果数组arr的值是null
        那么我们就抛岀空指针昇常，告知方法的调用者"传递的数组的值是null"
         */
        if(arr==null){
            throw new NullPointerException("传递的数组是空");
        }
        /*
        我们可以对传递过来的参数index进行合法性校验
        如果index的范围不在数组的索引范围内
        那么我们就批岀数组索引越界异常，告知方法的调用者“传递的索引超岀了数组的使用范围”
         */
        if (index<0||index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超岀了数组的使用范围");
        }
        int ele=arr[index];
        return ele;
    }
}

Objects非空判断
Objects类，它由一坐静态的实用方法组成，这些方法是 null-save（空指针安全的）或 null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

public static<T> T requireNonNull(T obj)//直看指定引用对象不是null

查看源码发现这里对为null的进行了抛出异常操作：

public static <T> T requireNonNull(T obj){
    if(obj == null)
		throw new NullPointerException ();
    return obj;
}

例如：

public class DemoObjects {
    public static void main(String[] args) {
        method(null);
    }
    public static void method(Object obj){
        //对传递过来的参数进行合法性判断，判断是否为null
//        if (obj==null){
//            throw new NullPointerException("传递过来的值为空");
//        }

//        Objects.requireNonNull()
        Objects.requireNonNull(obj,"传递的对象的值是null");
    }
}

声明异常throws

声眀异常：将问题标识岀来，报告给调用者。如果方法通过 throw抛岀了编译时异常，而没有捕获处理，那么必须通过 throws进行声明，让调用者去处理。
缺点：
异常如果异常一直没有处理，直到最后丢给最后JVM处理（中断），如果出现异常则后续代码不会执行
关键字throws运用于方法声明之上用于表示当前方法不处理异常，而是提酲该方法的调用者来处理异常（抛出异常）。最终交给JVM处理—>中断处理
注意：

1. throws关键字必须卸载方法声明处
2. throws关键字后面声明的异常必须是Exception或者Exception的子类
3. 方法内部如果抛出了多个异常对象，那么 throws后边必须也声明多个异常 如果批出的多个异常对象有子父类关系，那么直接声明父类异常即可
4. 调用了一个声明抛出异常的方法，我们就必须的处理声明的异常 要么继续使用 throws声明抛出，交给方法的调用者处理，最终交给JVM， 要么try…catch自己处理异常
   (方法声明时使用)声明异常格式:

修饰符 返回值类型 方法名 (参数) throws AAAException,BBBException...{ 
	throw new AAAException("产生原因");
    throw new BBBException("产生原因");
}

例如：

public class Demo05Throws {
    public static void main(String[] args) throws FileAlreadyExistsException,IOException {
        readFile("c:\\a.tx");
    }
    /*
    定义一个方法，对传递的文件路径进行合法性判断
    如果路径不是"c:\\a.txt"，那么我们就抛出文件找不到异常对象，告知方法的调用者意
    注意：
        FileNot FoundException是编译异常，抛出了编译异常，就必须处理这个异常
        可以使用 throws继续声明抛出 FiLeNotFoundException这个异常对象，让方法的调用者处理
        但是IOException是FiLeNotFoundException的父类所以可以只用写IOException
     */
    public static void readFile(String fileName) throws FileAlreadyExistsException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileAlreadyExistsException("传递的文件不是c:\\\\a.txt");
        }
        System.out.println("路径没问题");
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件后缀不对");
        }
    }
}

捕获异常try...catch

如果异常出现的话会立刻终止程序所以我们得处理异常:

1. 该方法不处理而是声明抛出，由该方法的调用者来处理（throws）
2. 在方法中使用 try…catch的语句块来处理异常。
   捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理
   捕获异常语法如下：

try{
    编写可能出现异常的代码
}catch (异常类型 变量名){
    处理异常的代码
    //记录日志/打印异常信息//继续抛出异常
}
...
catch(异常类型 变量名){
    
}

注意事项：

1. try中可能会抛出多个异常对象，那么就可以使用多个 catch来处理这些异常对象
2. 如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try…catch之后的代码
3. 如果try中没有产生异常，那么就不会执行 catch中异常的处理逻辑，执行完try中的代码，继续卖执行try…catch之后的代码
4. 如果try中产生异常后，try代码里除了抛出多个异常对象外还有后续代码，则后续代码不会执行。
   例如：

public class Demo05Throws {
    public static void main(String[] args){
        try{
            readFile("c:\\a.tx");	
            //传递的不是指定参数则执行catch和后续代码
            //如果是则跳过catch执行，继续执行后续代码
        }catch (IOException e){
            System.out.println("传递的文件不正确");
        }
        System.out.println("后续代码");
    }
    public static void readFile(String fileName) throws FileAlreadyExistsException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileAlreadyExistsException("传递的文件不是c:\\\\a.txt");
        }
        System.out.println("路径没问题");
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件后缀不对");
        }
    }
}

Throwable类中定义了一些查看方法：
public String getMessage():获取异常的描述信息原因提示给用户的时候,就提示错误原因。
public String toString()：获取异常的类型和异常描述信息（不用）(直接打印异常就是打印异常的toString方法)。
public void printstackTrace():打印异常的跟踪栈信息并输出到控制台。
包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段都得使用 printStackTrace。
例如：

public class Demo05Throws {
    public static void main(String[] args){
        try{
            readFile("c:\\a.tx");	
            //传递的不是指定参数则执行catch和后续代码
            //如果是则跳过catch执行，继续执行后续代码
        }catch (IOException e){
            System.out.println("传递的文件不正确");
            
            //java.nio.file.FileAlreadyExistsException: 传递的文件不是c:\\a.txt
            System.out.println(e);
            
            //传递的文件不是c:\\a.txt
            System.out.println(e.getMessage()); 
            
            //java.nio.file.FileAlreadyExistsException: 传递的文件不是c:\\a.txt
            System.out.println(e.toString());
            
            //最全面包括异常产生的原因 位置 内容
            //java.nio.file.FileAlreadyExistsException: 传递的文件不是c:\\a.txt
           	e.printStackTrace();
            
        }
        System.out.println("后续代码");
    }
    public static void readFile(String fileName) throws FileAlreadyExistsException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileAlreadyExistsException("传递的文件不是c:\\\\a.txt");
        }
        System.out.println("路径没问题");
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件后缀不对");
        }
    }
}

finally代码块

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

什么时候的代码必须最终执行？
当我们在try语句块中打开了一些物理资源（磁盘文件/网络连接/数据库连接等）我们都得在使用完之后最终关闭打开的资源。
语法：

try{
    编写可能出现异常的代码
}catch (异常类型 变量名){
    处理异常的代码
    //记录日志/打印异常信息//继续抛出异常
}
...
catch(异常类型 变量名){
    
}finally{
    无论是否出现异常都会执行
}

注意
finally不能单独使用。
finally一般用于资源释放（资源回收），无论程序是否岀现昇常，最后都要资源释放（IO）
异常的注意事项
多个异常使用捕获又该如何处理呢？

• 多个异常分别处理。
• 多个异常一次捕获，多次处理
• 多个异常一次捕获一次处理。
• 一个try多个catch注意事项:
  catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错
  原理：
• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。
• 如果父类抛出了多个异常子类覆盖父类方法时只能抛出相同的异常或者是他的子集
• 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
• 在 try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收
• 如果finally有return语句永远返回finally中的结果，避免该情况
  例如：

 public static void main(String[] args) {
     System.out.println(getA());	//100
 }

public static int getA(){
            int a=10;
            try{
                return a;
            }catch (Exception e){
                System.out.println(e);
            }finally{
                //一定会执行的代码
                a=100;
                return a;
}

自定义异常

为什么需要自定义异常类：
java中不同的异常类分别表示看某一种具体的异常情况，那么在开发中总是有些异常情况是SUN没有定义好的，此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题考试成绩负数问题等等。

什么是自定义异常类
在开发中根据自己业务的异常情况来定义异常类
自定义一个业务逻辑异常：RegisterEXception。一个注册异常类。

异常类如何定义：
自定义一个编译期异常：自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类：自定义类并继承于java.lang.RuntimeException。
格式：

public class XXXException extends Exception | RuntimeException{
    添加一个空参数的构造方法
    添加一个带异常信息的构造方法
}

注意：

1. 自定义异常类一般都是以 Exception结尾，说明该类是一个异常类 自定义异常类，
2. 必须的继承 Exception或者RuntimeException

• 继承 Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么 throws，要么try…catch
• 继承 RuntimeException：那么自定义的昇常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
  例如：

public class RegisterException extends Exception {
   //添加一个空参构造

    public RegisterException() {
        super();
    }

    //添加一个带异常信息的构造方法
	//查看源码发现所有的异常类都会有一个带常信息的构造方法，方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
    public RegisterException(String message) {
        super(message);
    }
}