Day05 异常及异常处理

异常

1. 异常概念

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

2. 异常体系

异常的跟类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception,通常异常指的是java.lang.Exception

• Error：严重错误Error，只能实现避免，无法处理的错误
• Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。
  异常的常用方法：
• public void printStackTrace()：打印异常的详细信息。包含了异常的类型、原因和出现的位置，在开发和调试阶段，都得使用printStackTrace方法。
• public String getMessage()：获取发生异常的原因。提示给用户的时候，就提示错误原因。
• public String toString()：获取异常的类型和异常描述信息（一般不用）。

3. 异常分类

java.lang.Throwable类是Java语言中所有错误和异常的超类
Exception：编译器异常，进行编译程序java程序出现的问题
RuntimeException：运行期异常，java程序运行过程中出现的问题
Error：错误，必须修改源代码，程序才能继续执行

4. 异常的产生过程

1. 程序运行过程中，JVM检测出程序出现异常，JVM此时做两件事

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

2. main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者JVM处理
3. JVM接收到了这个异常对象：

• 把异常对象(内容、原因、位置)以红色字体打印在控制台
• JVM会终止当前正在执行的java程序

异常处理

1. throw关键字

作用：可以使用throw关键字在指定的方法中抛出指定的异常
使用格式：throw new xxxException(“异常产生的原因”)；
注意：

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

2. Objects非空判断

Objects类中的静态方法public static <T> requireNoNull(T obj)：查看指定引用对象不是null。
源码：

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

3. 声明异常throws

throws关键字：异常处理的第一种方式，交给方法调用者处理。
作用：当方法内部抛出异常对象的时候，我们必须处理这个异常对象。此时可以使用throws关键字处理异常对象，throws关键字会把异常对象抛出给方法的调用者处理，最终交给JVM处理。
格式：

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

注意事项：

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

3. 捕获异常try…catch

try…catch：异常处理的第二种方式，捕获异常
格式：

try{
	可能产生异常的代码
}catch(异常类名	变量名) {
	异常的处理逻辑
	一般在工作中，会把异常的信息记录到一个日志中
}
...
catch(异常类名	变量名) {
	异常的处理逻辑
}

注意：

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

4. 获取异常信息的方法

• public String getMessage()：获取异常的描述信息、原因；
• public String toString()：获取异常的类型和异常描述信息
• public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、原因和出现的位置，在开发和调试阶段，都得使用printStackTrace

5. finally代码块

格式:

try{
	可能产生异常的代码
}catch(异常类名	变量名) {
	异常处理逻辑
}
...
catch(异常类型	变量名) {
	异常处理逻辑
}finally{
	无论是否出现异常都会执行
}

6. 异常注意事项

• 多个异常处理方式

1. 分别处理

        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]); 
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }

        try{
            List<Integer> list = new ArrayList<>();
            Collections.addAll(list,1,2,3);
            System.out.println(list.get(3));
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }
      
        System.out.println("后续代码");

2. 多个异常一次捕获，多次处理

		try{
            List<Integer> list = new ArrayList<>();
            Collections.addAll(list,1,2,3);
            System.out.println(list.get(3));
           
            int[] arr = {1,2,3};
            System.out.println(arr[3]); //ArrayIndexOutOfBoundsException: 3
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }

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

3. 多个异常一次捕获，一次处理

        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);
            
            List<Integer> list = new ArrayList<>();
            Collections.addAll(list,1,2,3);
            System.out.println(list.get(3));
        }catch (Exception e){
            System.out.println(e);
        }
        
        System.out.println("后续代码");

• 运行时异常被抛出可以不处理，即不捕获也不声明抛出
• 如果finally有return语句，永远返回finally中的结果，避免该情况
• 如果父类抛出了多个异常,子类重写父类方法时,抛出异常的类型可以是和父类相同的异常或父类异常的子类或者不抛出异常
• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常；若子类产生该异常，只能捕获处理，不能声明抛出

7. 自定义异常类

格式：

public class RegisterException extends Exception | RuntimeException {
	public RegisterException (){
		super();
	}
	
	public RegisterException(String message){
		super(mesage);
	}
}

注意：

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

• 继承Exception：自定义异常类是一个编译期异常，如果方法内部出现了编译期异常，必须通过throws或者try…catch来处理这个异常
• 继承RuntimeException：自定义异常类是一个运行期异常，无需处理，交给JVM处理（中断处理）

自定义异常类练习：

import java.util.Scanner;

public class PracticeException {
    static String[] usernames = {"张三", "李四", "王五"};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入您的用户名：");
        String username = sc.next();

        for (String name : usernames) {
            if (name.equals(username)) {
                throw new RegisterException("亲，该用户名已经被注册！");
            }
        }
        System.out.println("恭喜您，注册完成！");
    }
}