JavaSE-异常

目录

[TOC]

第一章:认识异常

1.1-什么是异常?

​ 异常,在Java程序中指的是:因程序问题而中断程序执行的现象。

1.2-异常分类

​ 在Java中,为了维护程序正常执行,Java提供了处理异常的异常机制(异常类)。

​ 在Java提供的异常机制中,其中java.lang.Throwable是根类,而根类的派生类有java.lang.Errorjava.lang.Excepiton两个子类。

Error,错误(绝症),该类型异常在程序中无法处理,只能尽量避免。

Excepiton,编译期异常(写源代码时)(小毛病,比如:类似感冒),该类型异常在程序中是可处理的。Excepiton类型还有一个子类RunTimeException,表示运行期异常(程序运行的过程中),该类型异常在程序中也是可处理的。

​ 为了更好的区分以上描述的异常分类,我们看以下程序。

// 【Error异常】
// Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
// 内存溢出。超出了分配给JVM内存大小。
// 该程序只能修改源代码解决问题。
int[]nums = new int[1024*1024*1024];

// 【Exception异常】
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// Unhandled exception: java.text.ParseException
// 此处在编写源代码时就发生异常,该异常后续可以通过相关的处理机制处理和避免
Date date = format.parse("2083-10-10"); 

// 【RunTimeException异常】
int[] nums = {1,2,3};
// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
// 在程序运行时出现的异常,数组下标超出。该异常可以通过相关异常机制处理
System.out.println(nums[4]);

1.3-异常产生的过程

在编程中,为了更好的处理异常,我们首先要了解异常产生的过程。下面通过一段异常代码来分析。

  • 代码

      // 需求:定义一个方法,用来获取指定数组的指定位置的元素
      public static void main(String[] args) {
        int[]nums = {1,2,3};
        System.out.println(getElement(nums,4));
      }
      public static int getElement(int[]arr,int index){
        return arr[index];
      }
    
  • 分析

    1. 在执行getElement方法的过程中,JVM检测出数组索引越界异常,此时JVM会做两件事:
      • 创建一个ArrayIndexOutOfBoundsException异常对象,该对象中包含了异常的信息(内容、原因、位置)
      • 因为getElment方法中没有异常处理,JVM会把异常对象抛给getElment方法的调用处-main方法。
    2. main方法接收到了ArrayIndexOutOfBoundsException异常对象,也没有处理异常,则会把异常对象抛给JVM
    3. JVM接收到了main方法后,会做两件事:
      • 在控制台打印异常信息(内容、原因、位置)
      • 终止程序的执行。
  • 图解

第二章:处理异常

2.1 关键字

异常相关的关键字有:

  • try
  • catch
  • finally
  • throw
  • throws

2.2 抛出异常-throw

  • 作用:在指定的方法内部抛出异常。

  • 格式throw new xxxException(参数)

    • 参数是字符串格式,用来描述异常。
  • 注意事项:

    1. throw关键字必须写在方法内部。
    2. throw关键字后创建的对象必须是Exception或Exception的子类对象。
    3. throw关键字抛出的异常对象,我们必须处理异常对象。
      • throw关键字抛出的时RunTimeException或RunTimeException子类异常对象时,我们可以不处理,因为JVM会默认处理(打印异常信息、中断程序)。
      • throw关键字抛出的时编译期异常时(编写源代码时),我们必须处理(可以通过throws或try-catch的方式处理)
  • 代码

      public static void main(String[] args) {
        int[]nums = {1,2,3};
        // getElement(nums,4); // 异常:java.lang.ArrayIndexOutOfBoundsException: 索引越界:4
        int[]nums2=null;
        getElement(nums2,0); // 异常java.lang.NullPointerException: 传入的数组对象为null
      }
      public static int getElement(int[]arr,int index){
        if(arr==null){
          throw new NullPointerException("传入的数组对象为null");
        }
        if(index<0||index>=arr.length){
          throw new ArrayIndexOutOfBoundsException("索引越界:" + index);
        }
        return arr[index];
      }
    

2.3 Objects非空判断

​ Objects中提供了一个方法,可以检测一个对象为null并抛出异常,我们来应用一下,并查看其源代码更好的理解throw关键字的应用。

  • 方法名称:public static T requireNonNull(T obj):查看指定引用对象不是null。

  • 源代码:

        public static  T requireNonNull(T obj) {
            if (obj == null)
                throw new NullPointerException();
            return obj;
        }
    
  • 应用:

      public static void main(String[] args) {
        int[]nums = {1,2,3};
        // getElement(nums,4); // 异常:java.lang.ArrayIndexOutOfBoundsException: 索引越界:4
        int[]nums2=null;
        getElement(nums2,0); // 异常java.lang.NullPointerException
      }
      public static int getElement(int[]arr,int index){
        Objects.requireNonNull(arr); // 应用
        if(index<0||index>=arr.length){
          throw new ArrayIndexOutOfBoundsException("索引越界:" + index);
        }
        return arr[index];
      }
    

2.4 声明异常-throws

当程序抛出一个异常对象给调用者时,调用者必须要处理异常,此时可以选择throws关键字来处理。

throws关键字的作用就是把异常对象继续抛给其他调用者,若其他调用者没有处理异常,则最终会抛给JVM来处理。

  • 格式

    /*
        修饰符 返回值类型 方法名() throws XXX1Exception,XXX2Exception... {
            throw new XXX1Exception("产生的原因");
            throw new XXX2Exception("产生的原因");
        }
    */
    
  • 注意事项

    1. throws关键字必须写在方法声明出。
    2. throws关键字后声明的异常必须是Exception或Exception子类异常。
    3. 方法内部抛出多个异常时,那么throws关键字后必须声明多个异常。
      • 如果抛出的多个异常之间存在继承关系,那么直接抛出父类即可。
    4. 调用了一个声明异常的方法,调用者必须处理该异常,处理方式有:
      • 调用者继续声明throws抛给其他调用者。最终抛给JVM。
      • 在调用者内部通过try-catch处理异常。
  • 代码

      // 需求:定义一个读取文件的方法,检测文件的路径和后缀名
      public static void main(String[] args) throws Exception {
        retFile("a.txt");
      }
      // 读取文件的方法
      //  private static void retFile(String path) throws FileNotFoundException,IOException {
      private static void retFile(String path) throws IOException {
        // 如果后缀名不是.txt则抛出
        if(!path.contains(".txt")){
          throw  new FileNotFoundException("文件后缀名不是.txt");
        }
        if(path.contains("c:")) {
          throw  new IOException("文件路径错误");
        }
      }
    

2.5 捕获处理异常-(try-catch)

throws声明异常的弊端是:异常后续代码无法执行(因为交给了JVM,JVM会终止程序)。

try-catch可以让调用者处理异常,并会继续执行后续程序。

  • 格式

    try {
        // 可能会发生异常的程序
        // 若发生异常,try会检测到异常对象
    }catch(异常类型 变量) {
        // catch会接收到异常对象,可以在此代码块中进行处理
    }catch(异常类型 变量) {
        // catch会接收到异常对象,可以在此代码块中进行处理
    }...
    
  • throwable中常用的异常方法

    • public String getMessage() :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
    • public String toString() :获取异常的类型和异常描述信息(不用)。
    • public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台。
      • 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
  • 代码

      // 需求:定义一个读取文件的方法,检测文件的路径和后缀名
      public static void main(String[] args)  {
        try{
          retFile("d.txt");
        }catch (Exception e) {
          e.printStackTrace();
        }
        System.out.println("后续代码");
        /*
         执行结果:
          java.io.IOException: 文件路径错误
                at it.leilei.cn.demo01.Main01.retFile(Main01.java:27)
                at it.leilei.cn.demo01.Main01.main(Main01.java:12)
            后续代码
        */
    
    
      }
      // 读取文件的方法
      private static void retFile(String path) throws IOException {
        // 如果后缀名不是.txt则抛出
        if(!path.contains(".txt")){
          throw  new FileNotFoundException("文件后缀名不是.txt");
        }
        if(!path.contains("c:")) {
          throw  new IOException("文件路径错误");
        }
      }
    
     
    

2.6 finally代码块

  • finally关键字的作用:有一些特定的代码无论异常是否发生,都需要执行。另外,因为异常会引发程序跳转,导致有些语句执行 不到。而finally就是解决这个问题的,在finally代码块中存放的代码都是一定会被执行的。

  • finally使用格式try...catch...finally自身需要处理异常,最终还得关闭资源。

  • finally关键字的应用场景:当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

  • 代码:

      // 需求:定义一个读取文件的方法,检测文件的路径和后缀名
      public static void main(String[] args)  {
        try{
          retFile("d.txt");
        }catch (Exception e) {
          e.printStackTrace();
        }finally {
          System.out.println("释放资源");
        }
        System.out.println("后续代码");
    
    
      }
      // 读取文件的方法
      private static void retFile(String path) throws IOException {
        // 如果后缀名不是.txt则抛出
        if(!path.contains(".txt")){
          throw  new FileNotFoundException("文件后缀名不是.txt");
        }
        if(!path.contains("c:")) {
          throw  new IOException("文件路径错误");
        }
      }
    

2.7 异常处理注意事项

  • 多个异常使用捕获又该如何处理呢?

    1. 多个异常分别处理。
    2. 多个异常一次捕获,多次处理。
    3. 多个异常一次捕获一次处理
  • 一般我们是使用一次捕获多次处理方式,格式如下:

    • 格式:

      try{ 
          编写可能会出现异常的代码 
      }catch(异常类型A e){ 
          当try中出现A类型异常,就用该catch来捕获. 
          处理异常的代码 
          //记录日志/打印异常信息/继续抛出异常 
      }catch(异常类型B e){ 
          当try中出现B类型异常,就用该catch来捕获. 
          处理异常的代码 
          //记录日志/打印异常信息/继续抛出异常 
      }
      
    • 注意:这种异常处理方式,要求多个catch中的异常不能相同,并且若catch中的多个异常之间有子父类异

      常的关系,那么子类异常要求在上面的catch处理,父类异常在下面的catch处理。

  • 运行时异常被抛出可以不处理。即不捕获也不声明抛出(JVM默认会进行处理)。

  • 如果finally有return语句,永远返回finally中的结果,避免该情况.

      public static void main(String[] args)  {
        int num = getNum();
        System.out.println(num); // 100
      }
      // 读取文件的方法
      public static int getNum() {
        int a = 10;
        try {
          return  a;
        }catch (Exception e){}
        finally {
          a = 100;
          return  a;
        }
      }
    
  • 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异 常。

    class Fu{
      // 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异 常。
      public void show1() throws IndexOutOfBoundsException{};
    }
    class Zi extends Fu{
      //  子类重写父类方法时,抛出和父类相同的异常
      // public void show1() throws IndexOutOfBoundsException{};
      // 或者是父类异常的子类ArrayIndexOutOfBoundsException 继承 IndexOutOfBoundsException
      // public void show1() throws ArrayIndexOutOfBoundsException{};
      // 不抛出异常
      public void show1()  {};
    }
    

第三章:自定义异常类

3.1 为什么要自定义异常类?

​ 我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

3.2 什么是自定义异常类?

​ 在开发中根据自己业务的异常情况来定义异常类.

​ 自定义一个业务逻辑异常: RegisterException。一个注册异常类。

3.3 如何定义异常类

  1. 自定义一个编译期异常: 自定义类 并继承于 java.lang.Exception 。
  2. 自定义一个运行时期的异常类:自定义类 并继承于 java.lang.RuntimeException 。

3.4 代码

要求:我们模拟注册操作,如果用户名已存在,则抛出异常并提示:亲,该用户名已经被注册。

  public static void main(String[] args)  {
    // 接收用户注册的用户名
    String name = new Scanner(System.in).next();
    try{
      check(name);
    }catch (RegisterException e){
      e.printStackTrace();
      return;
    }
    System.out.println("注册成功");
  }

  public static void check(String n) throws RegisterException{
    String[]users={"张三","李四","王五"};
    for (int i = 0; i < users.length; i++) {
      if (n.equals( users[i])) {
        throw new RegisterException("亲,该用户名已经注册");
      }
    }
  }
 

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

}

你可能感兴趣的:(JavaSE-异常)