Java--异常

一、概念

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

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

二、异常体系

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

1.Throwable体系

• Error：严重错误Error，无法通过处理的错误，只能事先避免。
• Exception：表示异常，异常产生后程序员可以通过代码的方式的纠正，使程序继续运行，使必须要处理的。

2.Throwable中的常用方法：

• public void printStackTrace():打印异常的详细信息。包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace。
• public String getMessage():获取发生异常的原因。提示用户的时候，就显示错误原因。
• public String tiString():获取异常的类型和异常描述信息。

三、异常分类

1.我们平常说的异常是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。
异常的分类：根据在编译时期还是运行时期去检查异常。

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

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    java.lang.Throwable:类是Java语言中所有错误或异常的超类。
        Exception:编译期异常，进行编译(写代码)Java程序出现的问题
            RuntimeException:运行期异常，Java程序运行过程中出现的问题。
        Error:错误
            必须修改源代码，程序才能继续执行。
 */
public class Demo01 {
    public static void main(String[] args) /*第一种处理异常：throws ParseException*/ {
        //Exception
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
        Date date = null;
        //第二种处理异常
        try {
            date = sdf.parse("1999-09-09");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);
        System.out.println("继续执行");

        //RuntimeException
        int[] arr = {1, 2, 3};
        System.out.println(arr[0]);
        //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
        try {
            //可能出现的异常
            System.out.println(arr[3]);
        } catch(Exception e) {
            //异常处理逻辑
            System.out.println(e);
        }
        System.out.println("继续执行");

        //Error
        //OutOfMemoryError:java heap space
        //内存溢出的错误，创建的数组太大了，超出了给Java分配的内存
        int[] array = new int [1024*1024*1024];//OutOfMemoryError
        System.out.println("后续代码");
    }
}

2.下面是一个错误的代码，我们通过这个代码来解析异常的产生过程（分析异常是怎样产生的，如何处理异常）

public class Demo02 {
    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;
    }
}

运行后结果如下：

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
at Exception.Demo02.getElement(Demo02.java:10)
at Exception.Demo02.main(Demo02.java:6)

①在getElement方法中访问了索引3，而数组中没有索引3，这时候，JVM就会检测出程序会出现的异常：
JVM会做两件事：

• JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容、原因、位置）
  eg：new ArrayIndexOutOfBoundsException（“3”）；
• 在getElement方法中，没有异常的处理逻辑(try…catch)，那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常。

②main方法接收到了这个异常对象(new ArrayIndexOutOfBoundsException（“3”）；)，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者JVM处理。

③JVM接收到了这个对象，做了两件事：

• 把异常对象（内容、原因、位置）以红色字体打印在控制台。
• JVM会终止当前正在执行的java程序–>中断处理

四、异常的处理

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

1.抛出异常throw

作用：可以使用throw关键字在指定的方法中，抛出指定的异常。
使用格式：

throw new xxxException(“异常产生的原因”);

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

我们首先必须对方法传递过来的参数进行合法性校验
如果参数不合适，我们就必须使用抛出异常的方式，告知调用者，传递的参数有问题。

public class Demo03throw {
    public static void main(String[] args) {
        //int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);//ArrayIndexOutOfBoundsException
        System.out.println(e);
    }
    public static int getElement(int[] arr, int index) {
        /*
        我们可以对传递过来的参数数组，进行合法性校验
        如果数组arr的值为null
        那么我们就会抛出空指针异常，告知调用者：传递的数组的值是null。
         */
        if(arr == null) {
            throw new NullPointerException("传递的数组的值是null");
        }
        /*
        对index进行合法性校验
        如果index的范围不在数组得到索引范围内
        那么我们就抛出数组索引越界异常，告知调用者“传递的索引超出了数组使用的范围”
         */
        if(index < 0 || index > arr.length) {
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组使用的范围");
        }
        int ele = arr[index];
        return ele;
    }
}

注意：

• NullPointerException是一个运行期异常，我们不处理，交给JVM处理；
• ArrayIndexOutOfBoundsException是一个运行期异常，我们不处理，交给JVM处理。

2.Objects非空判断

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

• public static T requireNonNull(T Obj);查看指定引用对象不是null。

源码如下：

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

eg：

import java.util.Objects;

public class Demo04Objects {
    public static void main(String[] args) {
        method(null);//NullPointerException: 传递对象的值是null
    }
    public static void method(Object obj) {//重载
        //对传递过来的参数进行合法判断，判断是否为null
        Objects.requireNonNull(obj,"传递对象的值是null");
    }
}

3.声明异常throws

1. throws关键字：异常处理的第一种方式，交给别人处理
   作用：
   当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
   可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理），最终交给JVM处理–>中断处理

2. 使用格式：在方法声明时使用
   修饰符 返回值类型 方法名(参数列表) throws AAAException,BBBException{
   throw new AAAException(“产生原因”);
   throw new BBBException(“产生原因”);
   …
   }

3. Notice:

• throws关键字必须写在方法声明出；
• throws关键字后边声明的异常必须时Exception或Exception的子类；
• 方法内部如果抛出多个异常对象，那么throws后边必须声明多个异常
  如果抛出的多个异常由字符类关系，那么直接声明父类异常即可；
• 调用了一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM；要么try…catch自己处理异常。

import java.io.FileNotFoundException;

public class Demo05throws {
    public static void main(String[] args) throws FileNotFoundException {
        readFile("C:\\\\a.txt");
    }
    /*
    定义一个方法，对传递的文件路径进行合法性判断
    如果路径不是"C:\\a.txt",那么就抛出文件找不到异常对象，告知方法的调用者
    Notice:
    FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
    可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
     */
    public static void readFile(String fileName) throws FileNotFoundException {
        if(!fileName.equals("C:\\\\a.txt")) {
            throw new FileNotFoundException("传递的文件路径不是C:\\\\a.txt");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

4.捕获异常try…catch

如果异常出现的话，会立刻终止程序，我们得处理异常：
1.该方法不处理，而是声明抛出，由该方法的调用者来处理（throws）；
2.在方法中使用try…catch的语句来处理异常。
try…catch的方式就是捕获异常。
捕获异常：Java中对异常由针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
捕获异常的语法如下：

try {
    可能产生异常的代码
} catch (定一一个异常的变量，用来接收try中抛出的异常对象) {
    异常处理逻辑，异常对象产生之后，怎么处理异常对象
    一般在学习工作中，会把异常的信息记录到一个日志中
}
...
catch (异常类 变量名) {

}

Notice:
1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象；
2.如果try中产生了异常，就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch后的代码；
如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try…catch后的代码。

public class Demo06tryCatch {
    public static void main(String[] args) throws IOException {
        try {//可能产生异常的代码
            readFile("C:\\\\a.txt");
        } catch (IOException e){//try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
            System.out.println("传递的文件后缀不是.txt");
        }
        System.out.println("后续代码");
    }

    public static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

如何获取异常信息：
Throwable类中定义了一些查看方法：

• String getMessage()返回此throwable的简短描述；
• String toString()返回此throwable的详细消息字符串；
• void printStackTrace()JVM打印异常对象，默认此方法，打印的异常信息是最全面的。

5.finally代码块

finally:有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的，例如，当我们在try语句中打开了一些物理资源（磁盘文件/网络连接/数据库连接等），我们都得在使用完之后，最终关闭打开的资源。

6.异常注意事项

多个异常使用捕获：
1.多个异常分别处理；
2.多个异常一次捕获，多次处理；
Notice：
catch里边定义的异常类，如果有子父类，那么子类的异常变量必须写在上边，否则就会报错
3.多个异常一次捕获一次处理

子父类的异常：
如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常类或者是父类异常的子类或者不抛出异常
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常此时子类产生该异常，只能捕获处理，不能声明抛出。

public class fu {
    public void show01() throws NullPointerException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() {}
}
class zi extends fu {
    //子类重写父类方法时，抛出和父类相同的异常
    public void show01() throws NullPointerException{}
    //子类重写父类方法时，抛出父类的异常类
    public void show02() throws IndexOutOfBoundsException{}
    //子类重写父类方法时，不抛出异常
    public void show03() {}
    /*
    父类方法没有抛出异常，子类重写父类该方法时也不可能抛出异常
    此时子类产生该异常，只能捕获处理，不能声明抛出，只能使用try...catch来处理
     */
    //public void show04() throws Exception{}
}

总之：

• 运行时异常被抛出可以不处理，即不捕获也不声明抛出，默认给虚拟机处理；
• 如果符类抛出多个异常，子类覆盖父类方法时，只能抛出相同的异常或者是它的子集；
• 父类方法没有抛出异常，子类覆盖父类方法时也不可抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出；
• 在try/catch后可以追加finally代码块，其中的代码块一定会被执行，通常用于资源回收；
• 如果finally有return语句，永远返回finally中的结果，避免该情况。

五、自定义异常

Java提供的异常类，不够我们使用，需要自己定义一些异常类。
格式：

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

Notice：
1.自定义异常类一般都是以Exception结尾，说明该类是一个异常类；
2.自定义异常类，必须得继承Exception或RuntimeException
继承Exception：那么自定义得异常类就是一个编译期异常，如果方法内部抛出一个编译期异常，就必须处理这个异常，要么throws，要么try…catch
继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）。

public class RegisterException extends Exception{
    public RegisterException () {

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