异常

异常

一、基本介绍

  • 基本概念:

    Java语言中,将程序执行中发生的不正常情况称为 “异常”。(开发过程中的语法错误和逻辑错误不是异常)

  • 执行过程中所发生的异常事件可以分为两类

    1. Error(错误):Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError[栈溢出] 和 OOM(out of memory),Error是严重错误,程序会崩溃。
    2. Exception:其他因编程错误或偶然的外在因素导致的一般性问题,可以是使用针对性的代码进行处理。例如空指针访问,试图读取不存在的文件,网络连接中断等等,Exception 分为两大类:运行时异常编译时异常
  • 异常体系图一览

    异常体系图一览

    编译异常&运行异常

    • 异常体系图小结:
      1. 异常分为两大类,运行时异常和编译时异常。
      2. 运行时异常,编译器检查不出来。一般是指编程时的逻辑错误,是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
      3. 对于运行时异常,可以不做处理,因为这类异常很普遍,若全处理可能会对程序的可读性和运行效率产生影响。
      4. 编译时异常,是编译器要求必须处置的异常。

二、运行时异常

  • 常见的运行时异常

    1. NullPointerException 空指针异常

      当应用程序试图在需要对象的地方使用 null 时,抛出该异常。

    2. ArithmeticException 数字运算异常

      当出现异常的运算条件时,抛出此异常。例如,一个整数除以零时,就会抛出此类的一个实例。

    3. ArrayIndexOutOfBoundsException 数组下标越界异常

      用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。

    4. ClassCastException 类型转换异常

      当试图将对象强制类型转换为不是实例的子类时,抛出该异常。

    5. NumberFormatException 数字格式不正确异常

      当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。

三、编译时异常

  • 介绍:编译异常是指在编译期间就必须处理的异常,否则代码不能通过编译。
  • 常见的编译异常
    • SQLException:操作数据库时,查询表可能发生异常
    • IOException:操作文件时,发生的异常
    • FileNotFoundException:当操作一个不存在的文件时,发生异常
    • ClassNotFoundException:加载类,而该类不存在时,异常
    • EOFException:操作文件,到文件末尾,发生异常
    • IllegalArguementException:参数异常

四、 异常处理机制

  • 基本介绍
    异常处理就是当异常发生时,对异常处理的方式

  • 异常处理的方式

    1. try-catch-finally

      程序员在代码中捕获发生的异常,自行处理

      try-catch-finally

    2. throws

      将发生的异常抛出,交给调用者(方法)来处理,最顶级的处理者就是JVM。

      在异常抛至JVM时,JVM会先输出异常信息,然后退出程序。

      throws

  1. 对于运行时异常,如果程序员没有显式处理异常,默认throws的处理;
  2. 对于编译异常,程序中必须处理,比如try-catch 或 throws;

五、 try-catch 异常处理

  • try-catch 方式处理异常说明

    1. Java 提供 try 和 catch 块来处理异常。try块用于包含可能出错的代码,catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try-catch块。

    2. 基本语法

      try{
          //可疑代码
          //将异常生成对应的异常对象,传递给catch块
      }catch(异常){
          //对异常的处理
      }finally{
          //一定被执行的语句
      }
      //如果没有finally,语法也可以通过
      
  • try-catch 方式处理异常——注意事项

    1. 如果异常发生了,则异常发生后面的代码就不会执行,直接进入到catch块中。

    2. 如果异常没有发生,则顺序执行try的代码块,不会进入到catch。

    3. 如果希望不管是否发生异常,都执行某段代码(比如关闭连接,释放资源等)则使用如下代码:finally{ };

    public class TryCatchDetail {
    public static void main(String[] args) {
    //1. 如果try中出现异常后,异常代码后的语句不会再执行,直接进入catch代码块
    //2. 如果异常没有发生,则顺序执行try的代码块,不会进入到catch
    //3. 如果希望不管是否发生异常,都执行某段代码(比如关闭连接,释放资源等)则使用如下代码 -finally
    try {
    String str = "韩顺平";
    int a = Integer.parseInt(str);
    System.out.println("数字:" + a);
    } catch (NumberFormatException e) {
    System.out.println("异常信息 = " + e.getMessage());
    }finally {
    System.out.println("finally代码块被执行...");
    }
    System.out.println("程序继续...");
    }
    }

    
    
    
    4. 可以有多个catch语句,捕获不同的异常(进行不同的业务处理),要求父类异常在后,子类异常在前,比如(Exception 在后,NullPotinterException 在前),如果发生异常,只会匹配一个catch,案例如下:
    
    ```java
    public class TryCatchDetail02 {
        public static void main(String[] args) {
            //1. 如果try代码块有可能有多个异常
            //2. 可以使用多个catch 分别捕获不同的异常,相应处理(一次只能捕获到一个异常,多个catch是为了应对不同情况)
            //3. 要求子类异常写在前面,父类异常写在后面
            try {
                Person person = new Person();
                person = null;
                System.out.println(person.getName());//NullPointerException
                int n1 = 10;
                int n2 = 0;
              int res = n1/n2;//ArithmeticException
            } catch (NullPointerException e){
              System.out.println("空指针异常 = " + e.getMessage());
            }catch (ArithmeticException e){
                System.out.println("算术异常 = " + e.getMessage());
            }catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
    
    class Person{
        private String name = "jack";
    
        public String getName(){
            return name;
        }
    }
    
    //运行结果:空指针异常 = null
    
    1. 可以进行try-finally 配合使用,这种用法相当于没有捕获异常,因此程序会直接崩掉/退出。应用场景:就是执行一段代码不管,否发生异常,都必须执行某个业务逻辑

      public class TryCatchDetail03 {
          public static void main(String[] args) {
              //可以进行try-finally 配合使用,这种用法相当于没有捕获异常
              //因此程序会直接崩掉/退出。应用场景:就是执行一段代码不管,否发生异常
              //都必须执行某个业务逻辑
              try {
                  int n1 = 10;
                  int n2 = 0;
                  System.out.println(n1/n2);
              } finally {
                  System.out.println("执行了finally...");
              }
              System.out.println("程序继续执行...");
          }
      }
      

六、 throws 异常处理

  • 基本介绍

    1. 如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显示地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法的调用者负责处理
    2. 在方法声明中用throws语句可以声明抛出异常的列表,即可以抛出多个异常,throws关键字后面的异常类型可以是方法中产生的异常类型,也可以时它的父类。
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class Throws01 {
        public static void main(String[] args) {
    
        }
        //4. throws后面的异常类型可以是方法中产生的异常,也可以是该异常的父类
        public void f2() throws FileNotFoundException,NullPointerException {//或者写 throws Exception
            //创建了一个文件流对象
            //1. 这里的异常是一个FileNotFoundException 编译异常
            //2. 可以使用前面的try-catch-finally
            //3. 也可以使用throws,抛出异常,让调用f2方法的调用者处理
            //5. throws 关键字后面也可以是 异常列表,即可以抛出多个异常
            FileInputStream fis = new FileInputStream("d://aa.txt");
        }
    }
    
  • 注意事项和使用细节

    1. 对于编译异常,程序中必须处理,比如try-catch 或 throws;
  1. 对于运行时异常,如果程序员没有显式处理异常,默认throws的处理;
  2. 子类重写父类方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致。要么为父类抛出异常类型的子类型
  3. 在throws 过程中,如果有方法 try-catch,就相当于处理异常,就可以不必throws
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  
  /**
   * @author
   * @version 1.0
   */
  public class ThrowsDetail {
      public static void main(String[] args) {
          f2();
      }
      public static void f2()/* throws ArithmeticException*/{
          //1. 对于编译异常,程序中必须处理,比如try-catch 或 throws
          //2. 对于运行时异常,程序中如果没有处理,默认就是throws的处理
          int n1 = 10;
          int n2 = 0;
          double res = n1/n2;
      }
  
      public static void f1() throws FileNotFoundException{
          //如果无 throws FileNotFoundException,则f3()调用报错
          //f3()方法将编译异常抛给了调用者f1()
          //编译异常必须处理,运行异常默认上抛
          //这时就要f1()必须处这个编译异常
          //在f1()中要么try-catch,要么继续上抛
          f3();
      }
  
      public static void f3() throws FileNotFoundException {
          FileInputStream fis = new FileInputStream("d://aa.txt");
      }
  
      public static void f4(){
          //这里调用没有问题
          //就算f5()有抛出的是运行异常
          //而Java中运行异常并不要求程序员显示处理,因为有默认处理机制,会自动继续上抛
          f5();
      }
      public static void f5() throws ArithmeticException{}
  }
  
  class Father{//父类
      public void method() throws RuntimeException{
  
      }
  }
  
  class Son extends Father{//子类
      //3. 子类重写父类方法时,对抛出异常的规定:子类重写的方法
      //所抛出的异常类型要么和父类抛出的异常一致。要么为父类抛出异常类型的子类型
      //4. 在throws 过程中,如果有方法 try-catch,就相当于处理异常,就可以不必throws
  
      @Override
      public void method() throws ArithmeticException {
  
      }
  }

七、 自定义异常

  • 基本概念

    当程序中出现了某些 “错误”,但该错误信息并没有在Throwable子类中描述处理,这个时候可以自己设计异常类,用于描述错误信息。

  • 自定义异常的步骤

    1. 定义类:自定义异常类名(程序员自己写)继承Exception或RuntimeException
    2. 如果继承Exception,属于编译异常
    3. 如果继承RuntimeException,属于运行异常(一般来说,继承RuntimeException)
  • 案例:

    public class CustomException {
        public static void main(String[] args) {
            int age = 180;
            //要求范围在18 - 120 之间,否则就抛出一个自定义的异常
            if(!(age >= 18 && age <= 120)){
                //这里可以通过构造器,设置信息
                throw new AgeException("年龄需要在18 - 120岁之间");
            }
            System.out.println("你的年龄范围正确");
        }
    }
    
    //自定义一个异常
    //1. 一般情况下,我们自定义异常是继承 RuntimeException
    //2. 即把自定义异常做成 运行时异常,好处是我们可以使用默认的处理机制,比较方便
    class AgeException extends RuntimeException{
        public AgeException(String message){
            super(message);
        }
    }
    

八、 throw 和 throws 的区别

意义 位置 后面跟的东西
throws 异常处理的一种方式 方法声明处 异常类型
throw 手动生成异常对象的关键字 方法体中 异常对象
posted @ 2022-12-30 16:56  凉白茶  阅读(516)  评论(0编辑  收藏  举报