一：异常处理方式

  1. try-catch-finally ：程序员在代码中捕获发生的异常自行处理
  2. throws 将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM

    1：try-catch-finally 处理机制示意图

    ```java try { //捕获到异常 //1：当一场发生时 //2：系统将异常封装成Exception对象e // 传递给catch //3：得到异常对象后，自己处理 //4：注意，如果乜有发生异常 //catch代码块不执行 } catch (Exception e) {

}finally { //1：不管try代码块是否发生异常，始终要执行finally //2：所以，通常将释放资源的代码，放在finally }

  1. <a name="eYwdC"></a>
  2. #### 2：throw示意图
  3. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/2595924/1661175599978-e35244cb-eaea-4c07-959e-191c444f1599.png#clientId=uea31069d-700c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=357&id=u1e1356b3&margin=%5Bobject%20Object%5D&name=image.png&originHeight=357&originWidth=640&originalType=binary&ratio=1&rotation=0&showTitle=false&size=182146&status=done&style=none&taskId=u0590c336-a994-4f1e-8a95-934bc487477&title=&width=640)
  4. :::info
  5. **_如果一直throw到JVM，JVM对于异常的处理就是 ：输出异常信息，退出程序_**
  6. :::
  7. ```java
  8. public class Test {
  9.     public static void main(String[] args) throws Exception {
  10.         int num1 = 10;
  11.         int num2 = 0;
  12.         //如果这个异常这个异常没有进行任何处理
  13.         //会有一个默认的throw
  14.         //这也就证明了我们如果没有进行任何处理
  15.         //程序就打印异常信息，然后退出程序
  16.          int res = num1 / num2;
  17.     }
  18. }

二：try-catch方式处理异常说明

  1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到 catch 块
  2. 如果异常没有发生，则顺序执行 try 的代码块，不会进入到 catch
  3. 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)，则加上finally ```java public class Test1 { public static void main(String[] args) {
    1.  try {
    2.      String name = "Sakura";
    3.      int num = Integer.parseInt(name);
    4.      System.out.println("转换后的数字为："+ num);
    5.  } catch (NumberFormatException e) {
    6.      System.out.println("捕获的异常为："+ e.getMessage());
    7.  }finally {
    8.      System.out.println("finally代码块被执行");
    9.  }
    10.  System.out.println("程序继续执行....");
    } }
  2. 1. **_如果 try 代码块有可能有多个异常_**
  3. 2. **_可以使用多个 catch 分别捕获不同的异常，相应处理_**
  4. 3. **_要求子类异常写在前面，父类异常写在后面_**
  5. ```java
  6. public class Test2 {
  7.     public static void main(String[] args) {
  8.         try {
  9.             Person person = new Person();
  10.             person = null;
  11.             System.out.println(person.getName());
  13.             int A = 10;
  14.             int B = 0;
  15.             int num = A/B;
  16.         }catch (NullPointerException e) {
  17.             System.out.println("空指针异常："+ e.getMessage());
  18.         }catch (ArithmeticException e){
  19.             System.out.println("算数异常"+e.getMessage());
  20.         }catch (Exception e){
  21.         }
  22.     }
  23. }
  24. class Person{
  25.     String name = "sakura";
  26.     public String getName() {
  27.         return name;
  28.     }
  29. }

  1. 可以进行try-finally 配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑

    1. public class Test2 {
    2.  public static void main(String[] args) {
    3.      try {
    4.          int A = 10;
    5.          int B = 0;
    6.          int num = A/B;
    7.      }finally {
    8.          System.out.println("出现异常，备份数据....");
    9.      }
    10.  }
    11. }

    三：异常处理课堂练习

    1：分析输出结果

    1. public class Test3 {
    2.  public static int method() {
    3.      int i = 1;
    4.      try {
    5.          i++;
    6.          String[] names = new String[3];
    7.          if (names[1].equals("tom")) {  //空指针异常
    8.              System.out.println(names[1]);
    9.          } else {
    10.              names[3] = "hspedu";
    11.          }
    12.          return 1;
    13.      } catch (ArrayIndexOutOfBoundsException e) {
    14.          return 2;
    15.      } catch (NullPointerException e) {
    16.          return ++i;
    17.      } finally {
    18.          return ++i;
    19.      }
    20.  }
    22.  public static void main(String[] args) {
    23.      System.out.println(method()); //4
    24.  }
    25. }
    1. public class Test3 {
    2.  public static int method() {
    3.      try {
    4.          String[] names = new String[3];
    5.          if (names[1].equals("tom")) {  //空指针异常
    6.              System.out.println(names[1]);
    7.          } else {
    8.              names[3] = "hspedu";
    9.          }
    10.          return 1;
    11.      } catch (ArrayIndexOutOfBoundsException e) {
    12.          return 2;
    13.      } catch (NullPointerException e) {
    14.          return 3;
    15.      } finally {
    16.          return 4;
    17.      }
    18.  }
    19.  public static void main(String[] args) {
    20.      System.out.println(method()); //4
    21.  }
    22. }
    1. public class Test3 {
    2.  public static int method() {
    3.      int i = 1;
    4.      try {
    5.          i++;
    6.          String[] names = new String[3];
    7.          if (names[1].equals("tom")) {  //空指针异常
    8.              System.out.println(names[1]);
    9.          } else {
    10.              names[3] = "hspedu";
    11.          }
    12.          return 1;
    13.      } catch (ArrayIndexOutOfBoundsException e) {
    14.          return 2;
    15.      } catch (NullPointerException e) {
    16.          return ++i;  //底层有一个temp临时变量保存3
    17.          //执行玩finally之后再执行return 3
    18.      } finally {
    19.           ++i; //i=4
    20.           System.out.println("i = " + i); //4
    21.      }
    22.  }
    24.  public static void main(String[] args) {
    25.      System.out.println(method()); //4 ，3
    26.  }
    27. }

    2：

    如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止

    1. public class Test4 {
    2.  public static void main(String[] args) {
    4.      Scanner scanner = new Scanner(System.in);
    5.      int num = 0;
    6.      while (true){
    7.          System.out.println("请输入一个整数：");
    8.          try {
    9.              num = Integer.parseInt(scanner.next());
    10.              break;
    11.          } catch (NumberFormatException e) {
    12.              System.out.println("你输入的不是整数,请重新输入");
    13.          }
    14.      }
    15.      System.out.println("输入的整数为："+ num);
    17.  }
    18. }

    四：try - catch - finally执行顺序小结

  2. 如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句

  3. 如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally，最后还需要执行finally里面的语句!