1，异常的概念：

异常就是可能出现了不正常的情况；

2，异常体系：

Error：严重问题，通过代码无法处理，比如：电源断电；
Exception：称为异常，表示程序本身可以处理的问题；

  1.   1. 编译时异常；（Exception）
  2.   1. 运行时异常；（RuntimeException）

3，虚拟机的默认异常处理：

  1. 默认处理方式：

    1. 编译异常，不给予运行；
    2. 运行时异常，停止程序；

      4，虚拟机的手动异常处理：（throws和try_ catch）

  2. throws：表明处理异常，如果真的出现问题时，这个异常就会抛给调用者；

  3. try_catch：
    1. 格式：（选中代码+快捷键：ctrl + alt + t）

try {
可能出现的异常代码；
} catch （异常类名 变量名）{
异常的处理代码；
}

  1.   2. 在catch里面的方法：

image.png

5，处理异常的原则：

不要把异常抛给JVM虚拟机即可；（main方法运行在JVM虚拟机）

  1. 方式 1：直接try——catch处理异常；

  2. 方式 2：

    1. 先throws；
    2. 后try_catch

      6，finally代码块：

  3. 作用：在这个代码块存放的代码都是一定会被执行的；

  4. 什么样的代码放到finally里：举例：资源的释放（IO流的关闭… ）；

  5. 场景代码：

    1. public class Text01 {
    2. public static void main(String[] args) {
    3.   try {
    4.       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    5.       Date parse = sdf.parse("2000lain-09yue-90ri");
    6.       System.out.println(parse);
    7.   } catch (ParseException e) {
    8.       System.out.println("dadadada");
    9.       e.printStackTrace();
    10.       return;
    11.   }finally {
    12.       System.out.println("finally");
    13.   }
    15. }
    16. }

    7，在继承中方法重写的异常处理：

  6. 子类中的重写方法throws的异常要比父类方法的异常相同或更多；

  7. 父类方法没有throws异常的情况下，子类方法只能try_catch处理；

    8，* 自定义异常：

    • 记得要在全局异常处理器中进行注册；否则不会有效执行 ```java package top.jztice5.reggie.exception;

import org.springframework.dao.DuplicateKeyException;

/**

  • @author Jztice5
  • @date 2022年04月07日 11:45 */

/**

  • 用户名重复异常处理类 */ public class DuplicateUserNameException extends DuplicateKeyException {
  1. public DuplicateUserNameException (String msg) {
  2.     super(msg);
  3. }

}

  1. ```java
  2. package top.jztice5.reggie.exception;
  4. /**
  5.  * @author Jztice5
  6.  * @date 2022年04月06日 20:57
  7.  */
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.web.bind.annotation.ControllerAdvice;
  11. import org.springframework.web.bind.annotation.ExceptionHandler;
  12. import org.springframework.web.bind.annotation.ResponseBody;
  13. import top.jztice5.reggie.common.R;
  15. /**
  16.  * 设置异常处理器
  17.  */
  18. //表示这是一个异常处理类
  19. @ControllerAdvice
  20. @Slf4j
  21. //该注解将会自动将返回的数据转换成JSON字符串
  22. @ResponseBody
  23. public class GlobalExceptionHandler {
  25.     /**
  26.      * 添加用户重名的异常处理注册
  27.      * @param e
  28.      * @return
  29.      */
  30.     //该注解：代表仅处理由该异常处理类传来的异常（DuplicateUserNameException）
  31.     @ExceptionHandler (DuplicateUserNameException.class)
  32.     //
  33.     public R <String> DuplicateKeyException (DuplicateUserNameException e) {
  34.         //将信息放到日志中；
  35.         log.info("====异常信息====");
  36.         e.printStackTrace();
  37.         //返回错误的信息到前端控制器
  38.         return R.error(e.getMessage());
  39.     }
  41.     @ExceptionHandler (value = Exception.class)
  42.     public R <String> handleException (Exception e) {
  43.         log.info("====异常信息====");
  44.         e.printStackTrace();
  45.         return R.error("异常信息：" + e.getMessage());
  46.     }
  48. }
  1.   - 异常的**抛出**：
  1.         //获取查询的对象
  2.         Employee userName = employeeMapper.setSelectUserName(username);
  3.         //将对象与异常信息一同传到异常处理类
  4.         if (userName != null){
  5.             throw new DuplicateUserNameException("该用户 "+userName.getUsername()+" 已存在,请重试");
  6.         }

9,在工作中如何处理异常：

  1. 运行时异常，一般修改代码；
  2. 空指针异常：常见于对象为null的情况下，在容易出现空指针异常的情况下要对对象是否为null进行判断，避免空指针异常；
  3. 编译时异常，必须处理，其中方式有两种：
    1. throws抛出异常；
    2. try_catch捕获异常；