JavaSE丨异常处理详解，高效应对程序中的“意外”

原创 于 2025-09-02 19:21:21 发布 · 808 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #java

一、异常

1.1 概述

        程序在运行过程中，由于意外情况导致程序发生异常事件，默认情况下发生的异常会中断程序的运行。

        在Java中，把常见的异常情况，都抽象成了对应的异常类型，那么每种异常类型都代表了一种特定的异常情况。

        当程序中出现一种异常情况时，也会创建并抛出一个异常类型对象，这个对象就表示当前程序所出现的问题。

如图：

        例如，程序中有一种异常情况是，当前使用下标从数组中取值的时候，这个下标值超过了数组下标的最大值，那么程序中就出现了异常情况，java中把这种异常情况抽象成了一个类： java.lang.ArrayIndexOutOfBoundsException ，表示程序中出现了数组下标超过边界的异常情况。

案例展示：

观察下面各种异常情况：

//如何理解异常：
// 程序不正常情况，统称为 异常
public class Test_Basic {
    public static void main(String[] args) {
        // ArithmeticException
        int a = 10 / 0;

        String s = "abc";
        //: NumberFormatException
        int n = Integer.parseInt(s);

        Object obj = new Object();//new String("hello");
        //类型转换异常：ClassCastException
        s = (String)obj;

        int[] arr = {1,2,3,4};

        arr = null;
        //空指针异常：NullPointerException
        System.out.println(arr[0]);

        //数组索引越界 ArrayIndexOutOfBoundsException
        System.out.println(arr[4]);
    }
}

运行结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Test_Basic.main(Test_Basic.java:6)

        可以看出，当前程序出现异常情况时，会创建并抛出和该异常情况对应的异常类的对象，这个异常对象中保存了一些信息，用来表示当前程序到底发生了什么异常情况。

        通过异常信息，我们可以定位异常发生的位置，以及异常发生的原因

1.2 异常体系

        异常体系中的根类是： java.lang.Throwable ，该类下面有两个子类型， java.lang.Error 和 java.lang.Exception

        注意：Throwable 表示可以被抛出的

  • Error ，表示错误情况，一般是程序中出现了比较严重的问题，并且程序自身并无法进行处理。
  • Exception ，表示异常情况，程序中出了这种异常，大多是可以通过特定的方式进行处理和纠正的，并且处理完了之后，程序还可以继续往下正常运行

1.3 异常种类

        我们平时使用的异常类型，都是两种：

  •  编译时异常
  •  运行时异常
编译时异常：
  • 继承自 Exception 类的子类型，也称为checked exception
  • 编译器在编译期间，会主动检查这种异常，如果发现异常则必须显示处理， 否则程序就会发生错误，无法通过编译
运行时异常 ：
  • RuntimeException 类及其子类，也称为unchecked exception
  • 编译器在编译期间，不会检查这种异常，也不要求我们去处理，但是在运行期间，如果出现这种异常则自动抛出

1.4 异常传播

        如果一个方法中出现了异常的情况，系统默认的处理方式是：自动创建异常对象，并将这个异常对象抛给当前方法的调用者，并一直向上抛出，最终传递给 JVM，JVM默认处理步骤有2步：

  1. 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
  2. 程序停止执行
案例展示：
public class Test_Default {
    public static void main(String[] args) {
        System.out.println("hello");
        test1();
        System.out.println("world");
    }

    public static void test1() {
        test2();
    }

    public static void test2() {
        test3();
    }

    public static void test3() {
        //下面代码会抛出异常
        int a = 1 / 0;
    }
}

运行结果：

hello
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Test_Default.test3(Test_Default.java:18)
	at Test_Default.test2(Test_Default.java:13)
	at Test_Default.test1(Test_Default.java:9)
	at Test_Default.main(Test_Default.java:4)
代码执行步骤解析：
  1. 因为 java.lang.ArithmeticException 是运行时异常，所以代码可以编译通过
  2. 程序运行时，先输出"hello"，然后一层一层调用，最终执行test3方法
  3. 执行test3方法时，出现除数为0的情况，系统自动抛出异常
  4. java.lang.ArithmeticException 代码中没有对异常进行任何捕获处理，所以该异常往上传递给test2 --> test1 --> main --> JVM
  5. JVM虚拟机拿到异常后，输出异常相关信息，然后终止程序

二、异常抛出

2.1 自动抛出

        Java代码中，出现了提前指定好的异常情况的时候，代码会自动创建异常对象， 并且将该异常对象抛出。

        例如，上述案例中执行 int a = 1/0; 的时候，代码会自动创建并抛出 ArithmeticException 类型的异常对象，来表示当前的这种异常情况。（算术异常）

        又如，代码中执行自动创建并抛出 String str = null; str.toString(); 的时候，代码会 NullPointerException 类型的异常对象，来表示当前这种异常情况。（空指针异常）

2.2 手动抛出

        以上描述的异常情况，都是JVM中提前规定好的，我们不需要干预，JVM内部自己就会创建并抛出异常对象。

        但是在其他的一些情况下，我们也可以手动的创建并抛出异常对象，抛出后系统也会按照默认的方式去处理。

        手动抛出异常固定格式： throw 异常对象;

案例展示：
public class AgeValidator {
    // 验证年龄的方法
    public static void checkAge(int age) {
        // 规定年龄必须在0-150之间，否则视为无效
        if (age < 0 || age > 150) {
            // 手动创建并抛出异常对象
            throw new IllegalArgumentException("年龄必须在0到150之间，当前值：" + age);
        }
        System.out.println("年龄验证通过：" + age);
    }

    public static void main(String[] args) {
        // 测试正常情况
        checkAge(25); // 年龄有效，会输出验证通过信息
        
        // 测试异常情况
        checkAge(-5); // 年龄无效，会触发手动抛出的异常
    }
}

三、异常处理

代码中出现了异常，除了默认的处理方式外，我们还可以手动处理异常：

  • 声明继续抛出异常，借助throws关键字实现
  • 捕获并处理异常，借助try、catch、finally关键字实现

3.1 throws

        throws关键字用于在方法声明中指定该方法可能抛出的异常类型。

        这个声明的目的，就是告诉方法的调用者，调用这个方法的时候要小心 ，方法在运行的时候可能会抛出指定类型的异常。

案例展示：

多个异常声明

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

public class ThrowsExample {
    // 声明该方法可能会抛出IOException和NullPointerException异常
    public static void processFile(String filePath) throws IOException, NullPointerException {
        if (filePath == null) {
            throw new NullPointerException("文件路径不能为null");
        }
        FileInputStream fis = new FileInputStream(filePath);
        // 其他文件处理逻辑
        fis.close();
    }

    public static void main(String[] args) {
        String filePath = null;
        try {
            processFile(filePath);
        } catch (IOException | NullPointerException e) {
            System.out.println("发生异常: " + e.getMessage());
        }
    }
}
我们将throw与throws进行一个对比：
对比维度throw 关键字throws 关键字
作用手动抛出一个具体的异常对象（触发异常）声明方法可能会抛出的异常类型（告知风险）
使用位置方法体内部（用于执行具体的异常抛出动作）方法签名末尾（用于声明异常，格式：方法名() throws 异常类型）
抛出内容必须是异常对象（如 throw new Exception()）必须是异常类型（如 throws IOException）
数量限制一次只能抛出一个异常对象可以声明多个异常类型，用逗号分隔（如 throws AException, BException）
处理要求抛出异常后，要么用 try-catch 处理，要么用 throws 声明抛给上层声明异常后，调用者必须处理（try-catch）或继续用 throws 向上声明
适用场景主动触发异常（如业务规则校验失败时）告知方法调用者 “此方法可能会引发这些异常，需注意处理”
总结
  • throw 是 “主动扔出一个具体的异常”（执行动作）；
  • throws 是 “提前声明方法可能会扔出哪些异常”（告知风险）。

3.2 try-catch

        try-catch 语句块，就是用来对指定代码，进行异常捕获处理，并且处理完成后，JVM不会停止运行，代码还可以正常的往下运行。

捕获异常语法：
 try {
    可能会出现异常的代码;
 }catch(异常类型 引用名) {
    //处理异常的代码，可以是简单的输出异常信息
    //也可以使用日志进行了记录，也可以对数据进行修改纠正等操作

    //一般输出异常信息
    //e.printStackTrace();
}

try：该代码块中包含可能产生异常的代码

catch：用来进行某种类型异常的捕获，并对捕获到的异常进行处理

执行流程：
  1. 程序从 try 里面的代码开始执行
  2. 出现异常，就会跳转到对应的 catch块 里面去执行
  3. 执行完毕之后，程序出 catch块，继续往下执行
案例展示：

模拟用户输入数字并进行除法运算的场景，处理可能出现的输入格式错误和除零异常

import java.util.Scanner;

public class DivisionCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("===== 除法计算器 =====");
        
        try {
            // 尝试获取用户输入的被除数
            System.out.print("请输入被除数（整数）：");
            String num1Str = scanner.nextLine();
            int num1 = Integer.parseInt(num1Str);  // 可能抛出NumberFormatException
            
            // 尝试获取用户输入的除数
            System.out.print("请输入除数（整数）：");
            String num2Str = scanner.nextLine();
            int num2 = Integer.parseInt(num2Str);  // 可能抛出NumberFormatException
            
            // 尝试执行除法运算
            int result = num1 / num2;  // 可能抛出ArithmeticException（除数为0时）
            
            // 如果以上步骤都没有异常，输出计算结果
            System.out.println("计算结果：" + num1 + " ÷ " + num2 + " = " + result);
        } 
        catch (NumberFormatException e) {
            // 处理输入格式错误（用户输入的不是整数）
            System.out.println("错误：请输入有效的整数！" + e.getMessage());
        } 
        catch (ArithmeticException e) {
            // 处理除法异常（除数为0）
            System.out.println("错误：" + e.getMessage() + "，除数不能为0！");
        }
        
        // 无论是否发生异常，都会执行以下代码
        System.out.println("\n程序执行结束，感谢使用！");
        scanner.close();
    }
}

上述案例中体现出，如果try语句块中的代码可能抛出多种异常，并且是不同类型的，则可以写多个 catch语句块，用来同时捕获多种类型异常。

注意事项：

这种异常处理方式，要求多个catch中的异常不能相同

如果catch中的多个异常类之间有子父类关系的话，那么子类异常必须写在父类异常上面的catch块中，父类异常必须写在下面的catch块中。 因为如果父类型异常再最上面的话，下面catch语句代码，永远不会被执行！

3.3 finally 语句 

        finally 关键字可以和 try、catch关键字一起使用，固定搭配为： try catch-finally ，它可以保证指定finally中的代码一定会执行，无论是否发生异常！

finally 块的主要作用：
  • 资源释放：在 try 块中打开的资源（例如文件、数据库连接、网络连接等） 可以在 finally 块中关闭或释放，以确保资源的正确释放，即使在发生异常的情况下也能够执行释放操作。
  • 清理操作： finally 块可以用于执行一些清理操作，例如关闭打开的流、释放锁、取消注册监听器等。
  • 异常处理的补充：finally块可以用于在try块和catch块之后执行一些必要的操作，例如记录日志、发送通知等。
案例展示：
import java.io.FileInputStream;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        FileInputStream fis = null; // 声明文件输入流变量
        
        try {
            // 尝试打开文件并读取内容
            fis = new FileInputStream("data.txt");
            System.out.println("文件打开成功，准备读取...");
            
            // 模拟读取过程中可能发生的异常（例如文件内容异常）
            int data = fis.read();
            if (data == -1) {
                throw new IOException("文件内容为空");
            }
            
            System.out.println("文件读取完成，内容：" + (char) data);
        } catch (IOException e) {
            // 处理文件操作相关异常
            System.out.println("文件操作出错：" + e.getMessage());
        } finally {
            // 无论是否发生异常，都必须关闭文件流（释放资源）
            System.out.println("进入finally块，准备关闭文件流...");
            if (fis != null) { // 确保流对象已初始化
                try {
                    fis.close(); // 关闭流可能也会抛出IOException
                    System.out.println("文件流已成功关闭");
                } catch (IOException e) {
                    System.out.println("关闭文件流时出错：" + e.getMessage());
                }
            }
        }
        
        System.out.println("程序执行结束");
    }
}

四、自定义异常

如果要自定义一个编译时异常类型，就自定义一个类，并继承 Exceptionn

如果要自定义一个运行时异常类型，就自定义一个类，并继承 RuntimeException

自定义异常步骤：

无论哪种类型的自定义异常，定义步骤基本一致，核心是 “继承父类 + 提供构造方法”：

  1. 定义异常类
    类名通常以 Exception 结尾（如 InvalidAgeException、PasswordErrorException），直观体现异常含义。

  2. 指定继承关系

    • 编译时异常：public class 自定义类名 extends Exception { ... }
    • 运行时异常：public class 自定义类名 extends RuntimeException { ... }

  3. 提供构造方法
    必须至少包含两种构造方法（通过 super() 调用父类构造）：

    • 空参构造：用于创建无详细信息的异常对象。
    • 带参构造：接收一个 String 类型的异常信息（描述错误原因），传给父类保存（便于通过 getMessage() 获取）。
案例展示：
// 自定义编译时异常
public class InvalidAgeException extends Exception {
    // 空参构造
    public InvalidAgeException() {
        super(); // 调用父类Exception的空参构造
    }
    
    // 带异常信息的构造
    public InvalidAgeException(String message) {
        super(message); // 调用父类Exception的带参构造，保存异常信息
    }
}

// 自定义运行时异常
public class EmptyNameException extends RuntimeException {
    public EmptyNameException() {
        super();
    }
    
    public EmptyNameException(String message) {
        super(message);
    }
}
噗噗欧耶
关注
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
异常处理代码（JAVASE）
09-19
异常处理是Java语言中用来处理程序运行时发生的错误的一种机制。它能够帮助开发者编写更安全、更健壮的代码，使得程序在遇到错误情况时能够更加优雅地处理，而不是简单地终止运行。在Java的标准版（JAVASE）中，异常...
JavaSE：异常处理机制 （学习笔记）
2301_81819439的博客
10-21 3105
异常处理机制，try - catch - finally , throws , throw , 异常的分类 ，Checked Exception 检查异常 ， Runtime Exception 运行时异常 ， 常见异常
【JavaSE】 try-catch 异常处理
兮动人
03-15 6167
9. try-catch 异常处理 9.1 try-catch 方式处理异常说明 Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用 于处理try块中发生的异常。可以根据需要在程序中有多个try…catch块。 基本语法 try { //可疑代码 //将异常生成对应的异常对象，传递给catch块 }catch(异常){ //对异常的处理 } //如果没有finally，语法是可以通过 9.2 try-catch 方式处理异常-快速入门 ...
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
温柔半两，从容一生
07-10 11万+
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
【JavaSE】异常处理机制
书生-w的博客
11-26 2万+
我们都知道在日常开发中，尽管努力地将代码写的尽善尽美，但在程序运行过程中，难免会出现一些奇奇怪怪的问题。有时通过代码很难去控制，比如：数据格式不对、网络不通畅、内存报警等。这就是Java的异常!
JavaSE——异常处理机制
chenchenchencl的博客
08-19 6069
一文搞定异常处理机制
Javase基础之异常处理篇笔记
A1163511759的博客
12-25 1798
Javase基础 一、 异常及处理 /** 异常：运行期间出现的错误，不是编译时出现的语法错误 异常分类： RuntimeException 运行时异常 非检查性异常 IOException 非运行时异常 检查性异常 */ 一般常见异常有如下图 1、AWTError（AWT组件出错）：这个错误并不是很常用。但是提一下AWT与Swing的区别，AWT是使用操作系统中的图形函数的抽...
JavaSE目录
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-04 36万+
跳转到总目录 01、版本一：视频教程笔记 这个版本是我跟着视频教程做的笔记 教程来源：java基础到高级_零基础自学Java–尚硅谷–宋红康 教程视频地址：https://www.bilibili.com/video/BV1ny4y1Y7CW 名称 笔记地址 一：Java语言概述 二：变量、标识符、保留字、变量 三：运算符 四：程序流程控制 五：数组 六：面向对象（上） 七：面向对象（下） 八：面向对象（中） 九：异常 十：多线程
【JavaSE】之异常
小新要变强的博客
10-07 3468
Java异常详细介绍，异常分类，异常体系，异常处理~
【JavaSE】Java中的异常那些事儿
bit me的博客
10-24 6974
在Java中我们写代码经常会遇到异常，那么这篇文章将带你认识各种异常及其处理方式，还可以帮你按照需求制造想要的异常类型
JavaSE文件IO流详解.pptx
06-08
JavaSE文件IO流详解
JAVASE基础知识详解
02-17
JAVASE基础知识详解
JavaSE进阶-04-异常处理.pdf
09-10
JavaSE 进阶课程中的异常处理是编程实践中至关重要的一个环节，它确保了程序在遇到错误时能够优雅地处理并提供反馈，而不是突然崩溃。以下是关于异常处理的详细说明： 1. **异常的基本概念** 异常是在程序运行过程...
2025年Java在中国开发语言排名分析报告
qq_33592535的博客
08-23 2044
成本维度：服务器集群规模缩减30%-60%，运维成本降低40%；体验维度：GC停顿缩短95%，秒杀场景响应延迟降低80%；弹性维度：云原生环境启动速度提升10倍，支持流量峰值快速扩容。这些改进不仅巩固了Java在企业级开发的地位，更使其在云原生、高并发场景中重新定义了性能标准。
make 函数概述与内部配置详解
最新发布
sqym1的博客
09-01 347
函数在切片、映射、通道三种核心引用类型的参数化配置，可以精细控制内存分配策略、并发同步行为以及运行时性能表现。：基于同一底层数组，可通过切分创建多个互不影响数据地址的切片视图。，减少再散列（rehash）次数和链长度，保证查找与插入性能。，但内部 1<<B 个桶已就绪，可高效插入前 16 对映射。标记结束，接收方可读出剩余缓存并返回零值，不再阻塞。，底层按照倍增策略重新分配更大数组，复制旧数据。，并据此分配内部桶（bucket）的数量，，并保证对象已被初始化，直接可用。切片：分配底层数组，并返回对应的。
GDPU操作系统实验：生产者消费者问题
平平无奇的小甜菜
08-31 927
本文摘要：实验通过信号量机制实现生产者-消费者模型，建立大小为10的缓冲区，使用3个生产者线程随机生成大小写字母，2个消费者线程取出字符。通过empty、full和mutex信号量实现同步与互斥，确保缓冲区访问安全。进阶实验扩展为选择性消费，增加3类消费者（仅小写/仅大写/任意字符），通过额外信号量管理不同类型产品。实验验证了进程同步中共享资源管理的有效性，演示了环形缓冲区和多线程协调的实现方法，为操作系统并发控制提供了实践案例。（149字）
145. 二叉树的后序遍历【简单】
伍六琪的博客
08-29 402
给你一棵二叉树的根节点 root ，返回其节点值的后序遍历 。【分别使用递归遍历和迭代遍历两种方式解决二叉树的后序遍历问题。】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值