Java 处理异常学习

与墨学长
56 阅读6分钟

异常概述与异常体系结构

异常概述

  • 异常：在 Java 中，将程序执行中发生的不正常情况称为“异常”。（开发过程中的语法错误和逻辑错误不是异常）。

  • Java 程序在执行过程中所发生的异常事件可分为两类：

    • Error：Java 虚拟机无法解决的严重问题。如：JVM 系统内部错误、资源耗尽等严重情况。比如： StackOverflowError 和 OOM。一般不编写针对性的代码进行处理。

    • Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：

      • 空指针访问
      • 试图读取不存在的文件
      • 网络连接中断
      • 数组角标越界

  • 对于这些错误，一般有两种解决方法：

    • 遇到错误就终止程序的运行。
    • 在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

  • 捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。比如：除数为 0，数组下标越界等。

    • 分类：编译时异常和运行时异常。

异常体系结构

 java.lang.Throwable
      |-----java.lang.Error：一般不编写针对性的代码进行处理。
      |-----java.lang.Exception：可以进行异常的处理。
                 |-----编译时异常（Checked）
                         |-----IOException
                             |-----FileNotFoundException
                         |-----ClassNotFoundException
                 |-----运行时异常（unchecked）
                         |-----NullPointerException
                         |-----ArrayIndexOutOfBoundsException
                         |-----ClassCastException
                         |-----NumberFormatException
                         |-----InputMismatchException
                         |-----ArithmaticException

异常处理机制一

  • Java 提供的时异常处理的抓抛模型。

  • Java 程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出(throw)异常。

  • 异常对象的生成：

    • 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。
    • 由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。

try-catch-finally 的使用

  • 结构：

     try{
   // 可能出现异常的代码
 } catch(异常类型1 变量名1) {
   // 处理异常的方式1
 } catch(异常类型2 变量名2) {
   // 处理异常的方式2
 } catch(异常类型3 变量名3) {
   // 处理异常的方式3
 }
 ......
 finally {
   // 一定会执行的代码
 }

    • 使用 try 将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去 catch 中进行匹配。一旦 try 中的异常对象匹配到某一个 catch 时，就进入 catch 中进行异常的处理。一旦处理完成，就跳出当前的 try-catch 结构(在没有写 finally 的情况) 。继续执行其后的代码。

    • catch 中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓；反之则要求子类一定要声明在父类的上面，否则会报错。

    • 常用的异常对象处理方式：

      • String getMessage()

    • printStackTrace()

    • 在 try 结构中声明的变量，在出了 try 结构以后，就不能再被调用。

    • try-catch-finally 结构可以相互嵌套。

  • 示例：

     public class ExceptionTest {
 ​
     @Test
     public void test1() {
         String str = "123";
         str = "abc";
         try {
             int num = Integer.parseInt(str);
         } catch (NumberFormatException e) {
             System.out.println("出现数值转换异常了，不要着急....");
             System.out.println(e.getMessage());
             e.printStackTrace();
         } catch (NullPointerException e) {
             System.out.println("出现空指针异常了，不要着急....");
         }
     }
 ​

}

   
 * **体会：使用 try-catch-finally 处理编译时异常，使得程序在编译时不再报错，但是运行时仍可能报错。相当于使用 try-catch-finally 将一个编译时可能出现的异常，延迟到运行时出现。**
 ​
 * finally 的使用
 ​
   * finally 是可选的
   * finally 中声明的是一定会被执行的代码。即使 catch 中又出现异常了，try 中有 return 语句，catch 中有 return 语句等情况。
   * 像数据库连接、输入输出流、网络编程 Socket 等资源，JVM 是不能自动回收的，需要手动进行资源的释放。此时的资源释放，就需要声明在 finally 中。
 ​
 * **体会：开发中，由于运行时异常比较常见，所以通常就不针对运行时异常编写 try-catch-finally 了。针对编译时异常，一定要考虑异常的处理。**
 ​
 ### throws 的使用
 ​
 * 结构
 ​
   ```Java
   throws + 异常类型
  • “throws + 异常类型” 写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足 throws 后异常类型时，就会被抛出。异常代码后续的代码就不会被执行。
  • 体会：try-catch-finally：真正的将异常处理掉了。throws 的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。

开发中如何选择 try-catch-finally 还是 throws ？

  • 如果父类中被重写的方法没有 throws 方式处理异常，则子类重写的方法也不能使用 throws ，意味着如果子类重写的方法中有异常，必须使用 try-catch-finally 方式处理。
  • 执行的方法中，先后调用了另外的几个方法，这几个方法是递进关系执行的。建议这几个方法使用 throws 的方式进行处理。而执行的方法可以考虑使用 try-catch-finally 方式进行处理。

方法重写的规则之一

  • 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

     public class OverrideTest {
 ​
     public static void main(String[] args) {
         OverrideTest test = new OverrideTest();
         test.display(new SubClass());
     }
 ​
     public void display(SuperClass s) {
         try {
             s.method();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 ​
 }
 ​
 class SuperClass {
     public void method() throws IOException {
 ​
     }
 }
 ​
 class SubClass extends SuperClass {
     @Override
     public void method() throws FileNotFoundException {
 ​
     }
 }
 ​

手动抛出异常

  • 关于异常对象的产生

    • 系统自动生成的异常对象。
    • 手动的生成一个异常对象，并抛出（throw）。

  • 示例：

     public class ThrowTest {
     public static void main(String[] args) {
         try {
             Student s = new Student();
             s.regist(-1001);
             System.out.println(s);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }
 ​
 class Student {
     private int id;
 ​
     public void regist(int id) throws Exception {
         if (id > 0) {
             this.id = id;
         } else {
             // 手动抛出异常对象
             // throw new RuntimeException("您输入的数据非法！");
             throw new Exception("您输入的数据非法！");
         }
     }
 ​
     @Override
     public String toString() {
         return "Student [id=" + id + "]";
     }
 }
 ​

用户自定义异常类

  • 如何自定义异常类？

    • 继承于现有的异结构：RuntimeException、Exception。
    • 提供 serialVersionUID 。
    • 提供重载的构造器。

  • 示例：

     public class MyException extends RuntimeException {
     static final long serialVersionUID = -7034897190745766939L;
 ​
     public MyException() {
 ​
     }
     
     public MyException(String msg) {
         super(msg);
     }
 }
 ​
avatar
文章
阅读
粉丝