本文链接：https://blog.csdn.net/m0_62967952/article/details/122686444

异常

概述

实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了...

软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception,意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃

异常指程序运行中出现的不期而至的各种状况。如：文件找不到（想用这个文件，但是用户给删掉了）、网络连接失败、非法参数等

异常发生在程序运行期间，它影响力正常的程序执行流程

分为三种类型的异常

1.检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序无法预见的。例如要打开一个文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略

2.运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略

3.错误：错误不是异常，而是脱离程序原控制的问题。错误在代码中通常被忽略。例如：当栈溢出时，一个错误就发生了，它们再编译也检查不到

异常体系框架

Java把异常当作对象处理，并定义一个基类java.lang.Throwable作为所有异常的超类（最高类）

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

在Exception分支中有一个重要的子类RuntimeException（运行时异常）

1.ArraylndexOutOfBoundsException（数组下标越界）

2.NullPointerException（空指针异常）

3.ArithmeticException（算术异常）

4.MissingResourceException（丢失异常）

5.ClassNotFoundException(找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常处理机制

抛出异常

处理异常

异常处理五个关键字：try,catch,finally,throw,throws

实际操作

try //监控区域

catch //捕获异常，这里是捕获的AritimeticException异常，把其命名为e

finally //处理最后的工作，不管有没有异常，甚至是有error都会执行fianlly代码块

  public class Application {
      public static void main(String[] args) {
          int a = 1;
          int b = 0;
          try{
              System.out.println(a/b);
          }catch (ArithmeticException e){
              System.out.println("出现异常");
          }finally {
              System.out.println("完成");
          }
      }
  }

try catch必须有，finally可以没有，finally的作用在于在IO流，资源等中去关闭对象

可以捕获多个错误，它是层层递进的关系，所以要先捕获小范围异常，然后再是大范围的异常

  public class Application {
      public static void main(String[] args) {
          int a = 1;
          int b = 0;
          try{
              System.out.println(a/b);
          }catch(Error e){
              System.out.println("出现错误");
          }catch(Exception e){
              System.out.println("出现异常e");
          }catch (Throwable t){
              System.out.println("出现异常t");
          }
          finally {
              System.out.println("完成");
          }
      }
  }

快捷键：ctrl+alt+t（选中要生成的语句）

e.printStackTrace 打印错误的栈信息

throw一般在方法中使用，主动抛出异常，throw new 异常名称

  
  public class Demo1 {
      public static void main(String[] args) {
          Demo1 d = new Demo1();
          d.suansu(1,0);
      }
      public void suansu(int a,int b){
          if(b==0){
              throw new ArithmeticException();//主动抛出异常
          }
      }
  }

  
  public class TryCatchDemo {
      public static void main(String[] args) {
          try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。
              read("b.txt");
          } catch (FileNotFoundException e) {// 括号中需要定义什么呢？
              //try中抛出的是什么异常，在括号中就定义什么异常类型
              System.out.println(e);
          }
          System.out.println("over");
      }
      /*
       *
       * 我们 当前的这个方法中 有异常  有编译期异常
       */
      public static void read(String path) throws FileNotFoundException {
          if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
              // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
              throw new FileNotFoundException("文件不存在");
          }
      }
  }

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

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

throws在方法上使用，方法处理不了这个异常先不处理，交给上一级（调用者）去处理

使用throws声明抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常应该由上一级调用者处理；如果main方法也不知道如何处理这种类型的异常，也可以使用throws声明抛出异常，该异常将交给JVM处理。JVM对异常的处理方法是：打印异常的跟踪栈信息，并终止程序运行，这就是前面程序在遇到异常后自动结束的原因。

在main方法里，由于sqrt方法的声明中有throws关键字，所以，在调用该方法时，必须对throws后面声明的异常进行处置，处置的方法有两种:

（1）main方法处理该异常，使用try.....catch语句，将可能会出现的异常的代码放在try块内，将处理异常的代码放在catch块内，并指明catch能够捕获的异常的类型，当异常被捕获时，执行catch块内的语句

（2）main方法不处理该异常，将异常向外层程序抛出。在方法声明中使用throws关键字抛出异常，方法体中不需要使用try...catch语句

  
  public class Demo1 {
      public static void main(String[] args)throws Exception {
          Demo1 d = new Demo1();
         try {
             d.suansu(1, 0);
         }catch (Exception e){
             System.out.println("处理异常");
         }
      }
      public void suansu(int a,int b) throws Exception{
          if(b==0){
              throw new ArithmeticException();//主动抛出异常
          }
      }
  }

throw在方法中抛出了异常，然后throws将这个异常传给调用者，调用者用try catch捕获这个异常e,并解决，throw new ArithmeticException只是对这个异常的描述，或者用try catch直接在方法中解决异常

  
  public class Demo1 {
          public static void main(String[] args)throws Exception {
              Demo1 d = new Demo1();
                  d.suansu(1, 0);
          }
          public void suansu(int a,int b){
              if(b==0){
                  try {
                      throw new ArithmeticException();//主动抛出异常
                  } catch (ArithmeticException e) {
                      System.out.println("出现异常");
                  }
              }
          }
      }

自定义异常类

使用JAVA内置的异常类可以描述在编程时出现的大部分异常情况，除此之外，用户还可以自定义异常，用户自定义异常，只需继承Exception类即可

在程序中使用自定义异常类，大体可以分以下几个步骤

1.创建自定义异常类

  
  public class MyException extends Exception{
      //自定义一个传递数字超过10的异常
      private int detail;
      //构造器
      public MyException(int a){
          detail = a;//detail描述所传入的异常数字
      }
      //打印信息，使用toString方法
      @Override
      public String toString() {
          return "MyException{" +
                  "detail=" + detail +
                  '}';
      }
  }

自定义异常类，extends Exception 编程异常类包括构造器，toString方法

2.在方法中通过throw关键字抛出异常对象3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

4.在出现异常方法的调用者中捕获并处理异常

  public class Test {
      public static void main(String[] args) {
          try {
              test(11);
          }catch (MyException e){
              System.out.println(e);
          }
      }
      public static void test(int a) throws MyException{
          if(a>10){
              throw new MyException(a);
          }
      }
  }