Java异常

一. 异常

1.1 异常的概念

• 异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

1.2 异常体系

异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Exception：异常

      编译期异常：在编译时期,就会检查，如果没有处理异常，则编译失败(报错)。

      RuntimeException：运行期异常，java程序运行过程中出现的问题

     异常就相当于程序得了一个小毛病(感冒，发烧)，把异常处理掉，程序就可以继续执行

Error：错误

     错误就相当于得了一个无法治愈的毛病，必须修改源代码，程序才能继续执行

Throwable中的常用方法：

• public void printStackTrace():打印异常的详细信息。

  包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

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

1.3 异常产生过程分析

public class Demo02Exception {
    public static void main(String[] args) {
        //创建int类型的数组，并赋值
        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

2.1 抛出异常throw

例如: 我们在给定义访问数组元素的方法时，要传入参数index，那么在方法的内部我们就需要对参数的合法性进行判断，若数据不合法，我们需要告诉调用者，传入的数据不合法。此时使用抛出异常的方法告诉调用者。

• throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
• throw关键字后面创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理(打印异常对象，中断程序)
• throw关键字后面创建的是编译异常(写代码时报错)，我们就必须处理这个异常，要么throws 要么try...catch。

使用格式：throw new 异常类名(参数);

例如：throw new ArrayIndexOutOfBoundsException("数组下标越界");

    public static int getElement(int[] arr,int index){
        if(arr == null){
            throw new NullPointerException("传递的数组的值为空");
        }
        if(index<0||index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("数组索引越界");
        }
        int ele = arr[index];
        return ele;
    }

当我们需要对传进来的对象进行判空时，可以直接使用Objects中的 requireNonNull()方法进行判空并抛出异常。

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续将问题声明出去，使用throws声明处理。

2.2 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上，用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)。

   public static void main(String[] args) throws IOException{
        readFile("d:\\a.txt");
    }

   public static void readFile(String fileName) throws IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }
        System.out.println("路径没有问题，读取文件");
    }

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

2.3 捕获异常try...catch

try-catch的方式就是捕获异常。

• 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

• try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
}

    public static void main(String[] args) {
        try{
            readFile("d:\\a.tx");
        }catch (IOException e){ 
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println(e);
        }
        System.out.println("后续代码");
    }
    /*
       如果传递的路径，不是.txt结尾
       那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
     */
    public static void readFile(String fileName) throws IOException{
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }

2.4 finally 代码块

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

finally的语法:

try...catch....finally:自身需要处理异常,最终还得关闭资源。

    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.txt");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        }finally{
            System.out.println("资源释放");
        }
    }
    /*
       如果传递的路径，不是.txt结尾
       那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
     */
    public static void readFile(String fileName) throws IOException {
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }

2.5 异常注意事项

• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。

• 如果finally有return语句，永远返回finally中的结果，尽量不要出现此类情况。

• 如果父类抛出了多个异常，子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

     //多个异常一次捕获，多次处理
     try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);

            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }

这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

2.6 自定义异常类

当Java提供的异常类不能满足我们开发的需求，我们可以定义自己的异常类。

格式：

public class XXXException extends Exception | RuntimeException{

           添加一个空参数的构造方法

           添加一个带异常信息的构造方法

}

自定义异常类，必须继承Exception或者RuntimeException

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

案例：模拟注册操作，如果用户名已存在，则抛出异常并提示：该用户名已经被注册。

/*
   自定义异常类
 */
public class MyException extends Exception{ //继承编译期异常
    //无参构造
    public MyException(){
        super();
    }
    //含有异常信息的构造
    public MyException(String message){
        super(message);
    }
}

/*
   自定义异常测试类
*/
import java.util.Scanner;

public class MyExceptionTest {
    static String[] userNames = {"张三","李四","王五"};
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String userName = sc.nextLine(); //传入的用户名
        checkUsername(userName); //检查是否已经注册
    }
    public static void checkUsername(String username){
        for (String name:userNames){
            if(name.equals(username)){ //已注册，处理异常
                try {
                    //继承Exception是编译期异常，抛出异常对象后，要么throws 要么try...catch
                    throw new MyException("该用户名已经被注册"); 
                } catch (MyException e) {
                    e.printStackTrace();
                    return; //处理完异常结束方法，否则程序继续执行下面打印语句
                }
            }
        }
        System.out.println("恭喜您，注册成功");
    }
}

如果我们不使用try...catch处理编译期异常，则使用throws，将异常上抛给方法调用处，最总由JVM进行中断处理。

运行期异常我们只需要抛出异常对象，无需进行处理，JVM会进行处理，将异常信息打印出来。