V2AS问路
【Java基础】异常处理
阅读原文时间：2023年07月09日阅读：2

异常处理

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

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

  • Error：JVM 无法解决的严重问题，一般不编写针对性的代码进行处理。例如：

    • StackOverflowError；
    • OutOfMemoryError

  • Exception：它因编程错误或偶然的外在因素导致的一般性问题，可以使

    用针对性的代码进行处理。例如：

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

捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。所以异常分为编译时异常和运行时异常。

编译时时异常：

  • 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
  • 对于这类异常，如果程序不处理，可能会带来意想不到的结果。

运行时异常：

  • 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException 类及它的子类都是运行时异常。
  • 对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。

常见异常：

  • java.lang.RuntimeException

    • ClassCastException；
    • ArrayIndexOutOfBoundsException；
    • NullPointerException；
    • ArithmeticException；
    • NumberFormatException；
    • InputMismatchException；
    • …

  • java.io.IOExeption

    • FileNotFoundException；
    • EOFException；

  • java.lang.ClassNotFoundException；

  • java.lang.InterruptedException；

  • java.io.FileNotFoundException；

  • java.sql.SQLException；

在编写程序时，经常要在可能出现错误的地方加上检测的代码，可能出现过多的 if-else 分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。

Java 采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

Java 异常处理的方式：

  • try-catch-finally;
  • throws + 异常类型。

Java 提供的是异常处理的抓抛模型。Java程序的执行过程中如果出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出（throw）异常。如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这个过程称为捕获（catch）异常。

其中，“抛”，可以理解为异常对象的产生，有 1. 系统自动生成的异常对象 和 2. 手动的生成的一个异常对象，并 throw。

其中，“抓”，可以理解为异常的处理方式，有 1. try-catch-finally 和 2. throws 。

异常对象的生成：

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

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法：

  • getMessage() 获取异常信息，返回字符串；
  • printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置，返回值 void。

语法格式：

try {
    // 可能产生异常的代码
} catch (ExceptionName1 e) {
    // 可选的，处理ExceptionName1型异常
} catch (ExceptionName2 e) {
    // 可选的，处理ExceptionName2型异常
} [ finally {
    // 可选的，无论是否发生异常，都无条件执行的语句
}]

注意：

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

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

  • 像数据库连接、输入输出流、网络编程 Socket 等资源，JVM 是不能自动回收的，需要自己手动的进行资源的释放，此时的资源释放，就需要声明在 finally 中;

    package com.parzulpan.java.ch04;

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;

    /**

    • @Author : parzulpan
    • @Time : 2020-11-22
    • @Desc : 异常处理机制：try-catch-finally
      */

    public class ExceptionTest {
    public static void main(String[] args) {
    // 最初版
    // try {
    // File file = new File("hello.txt");
    // FileInputStream fileInputStream = new FileInputStream(file);
    //
    // int data = fileInputStream.read();
    // while (data != -1) {
    // System.out.println((char) data);
    // data = fileInputStream.read();
    // }
    // fileInputStream.close();
    // } catch (IOException e) {
    // e.printStackTrace();
    // }

        // 改进版
    FileInputStream fileInputStream = null;
    try {
        File file = new File("hello.txt");
        fileInputStream = new FileInputStream(file);
        int data = fileInputStream.read();
    while (data != -1) {
        System.out.println((char) data);
        data = fileInputStream.read();
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fileInputStream != null) {
            fileInputStream.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
    }

    }

不捕获异常时的情况：

  • 对于运行时异常，例如 RuntimeException 类或是它的子类等，这些类的异常的特点是：即使没有使用 try 和 catch 捕获，Java 自己也能捕获，并且编译通过，但运行时会发生异常使得程序运行终止。
  • 对于编译时异常，例如 是IOException 等，则必须捕获，否则编译错误。
  • 必须处理编译时异常，将异常进行捕捉，转化为运行时异常。

如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这

种异常，则此方法应显式地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

package com.parzulpan.java.ch04;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @Author : parzulpan
 * @Time : 2020-11-22
 * @Desc : 异常处理机制：throws + 异常类型
 */

public class ExceptionTest1 {
    public static void main(String[] args) {

        try {
            method();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void method() throws IOException {
        File file = new File("hello.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

        int data = fileInputStream.read();
        while (data != -1) {
            System.out.println((char) data);
            data = fileInputStream.read();
        }

        fileInputStream.close();
    }
}

注意：try-catch-finally 是真正的将异常给处理掉了，而 throws 的方式只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。

重写方法声明抛出异常的原则：

  • 重写方法不能抛出比被重写方法范围更大的异常类型。这是因为多态性存在的缘故。

try-catch-finally 和 throws 的选择：

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

Java 异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

首先要生成异常类对象，然后通过 throw 语句实现抛出操作（提交给 Java 运行环境），可以抛出的异常必须是 Throwable 或其子类的实例：

IOException e = new IOException();
throw e;


package com.parzulpan.java.ch04;

/**
 * @Author : parzulpan
 * @Time : 2020-11-22
 * @Desc : 手动抛出异常
 */

public class ExceptionTest2 {
    public static void main(String[] args) {
//        StudentAA studentAA = new StudentAA();
//        studentAA.add(-10);
//        System.out.println(studentAA);  // 请输入的数据非法！StudentAA{id=0}
        try {
            StudentAA studentAA = new StudentAA();
            studentAA.add(-10);
            System.out.println(studentAA);  // 请输入的数据非法！
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }
}

class StudentAA {
    private int id;

    public void add(int id) throws Exception{
        if (id > 0) {
            this.id = id;
        } else {
//            System.out.println("请输入的数据非法！");
            // 手动抛出异常
            throw new Exception("请输入的数据非法！");
        }
    }

    @Override
    public String toString() {
        return "StudentAA{" +
                "id=" + id +
                '}';
    }
}

注意：

  • 一般地，用户自定义异常类都是 RuntimeException/Exception 的子类；

  • 自定义异常类通常需要编写几个重载的构造器；

  • 自定义异常需要提供 serialVersionUID；

  • 自定义的异常通过 throw 抛出；

  • 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

    package com.parzulpan.java.ch04;

    /**

    public class MyExceptionTest {
    public static void main(String[] args) {
    MyExceptionTest myExceptionTest = new MyExceptionTest();
    myExceptionTest.manager();
    }

    public void add(int num) throws MyException{
    if (num < 0) {
        throw new MyException("人数为负值，不合理", 3);
    } else {
        System.out.println("登记人数 " + num);
    }
}

public void manager() {
    try {
        add(-10);
    } catch (MyException e) {
        System.out.println(e.getMessage());
        System.out.println("登记失败，出错种类 " + e.getId());
    }
    System.out.println("本次登记操作结束");
    }

    }

    class MyException extends Exception {
    static final long serialVersionUID = 2165326351631265L;
    private int id;

    public MyException(String msg, int id) {
    super(msg);
    this.id = id;
}

public int getId() {
    return id;
}

    }

判断程序的输出结果？

public class ReturnExceptionDemo {
    static void methodA() {
        try {
            System.out.println("进入方法A");    // 1
            throw new RuntimeException("制造异常"); // 2
        } finally {
            System.out.println("用A方法的finally");     // 3
        }
    }

    static void methodB() {
        try {
            System.out.println("进入方法B");    // 4
            return;
        } finally {
            System.out.println("调用B方法的finally");   // 5
        }
    }

    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        methodB();
    }
}

输出：1 -> 3 -> 2 -> 4 -> 5

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章

[转]PHP并发IO编程之路（深度长文）
容器、微服务和服务网格简史
面向 Kubernetes 编程：Kubernetes 是下一代操作系统

4

微服务中的熔断简介及工作原理详解（第2部分）

5

Istio服务网格的崛起

6

蚂蚁金服大规模微服务架构下的Service Mesh探索之路

7

服务网格架构激活了容器网络管理—来自于服务网格创建者们的见解与展望

8

微服务通信的设计模式

9

深入探讨I/O模型：Java中的阻塞和非阻塞和其他高级IO应用

10

log4j2同步日志引发的性能问题