java的异常-Exception、Error

花花无缺2025-08-22 9:44

Java 异常机制是一种"分离正常逻辑与错误处理"的编程方式，合理使用可以让程序更健壮、更易维护。核心机制 ：try-catch-finally 和 throws

Java 异常的继承体系

Java 中所有异常和错误都继承自 Throwable 类。其主要分为Error 和Exception两大类：异常是"可恢复的问题"，错误是"不可恢复的灾难"

php 复制代码 
                Throwable
                   |
        -------------------------
        |                       |
     Error                  Exception
                              |
                   -------------------------
                   |                       |
           Checked Exception       Unchecked Exception
                                   (RuntimeException 及其子类)

1. Error（错误）

  • 表示 JVM 无法处理的严重问题，通常程序无法恢复。

  • 常见例子：

    • OutOfMemoryError：内存不足
    • StackOverflowError：栈溢出（如无限递归）

  • ⚠️ 程序一般不捕获 Error，也无法恢复。

2. Exception（异常）

  • 表示程序可以处理的异常情况。

  • 分为两类：检查异常（Checked）和未检查异常（Unchecked）

  • 检查异常 vs 未检查异常

对比项 检查异常（Checked） 未检查异常（Unchecked）
编译器是否强制处理 ✅ 是（必须 try-catch 或 throws） ❌ 否
继承自 Exception（非 RuntimeException） RuntimeException
表示问题类型 外部环境问题（如文件不存在、网络断开） 程序逻辑错误（如空指针、越界）
是否应该捕获 ✅ 应该处理或提示用户 ❌ 应通过代码避免，而不是捕获
常见例子 FileNotFoundException, SQLException,IOException NullPointerException, IllegalArgumentException

3、异常处理的 5 个关键字

关键字 作用
try 包裹可能出错的代码
catch 捕获并处理特定类型的异常
finally 无论是否出错都执行（用于资源清理）
throw 主动抛出一个异常
throws 声明方法可能抛出的异常类型

异常处理流程图

csharp 复制代码 
       try
        ↓
   执行业务代码
        ↓
    是否发生异常？
       ↙     ↘
    是       否
    ↓         ↓
 catch块     finally块
    ↓         ↓
 处理异常   清理资源
    ↓         ↓
       方法结束

示例代码：

java 复制代码 
    // 方法1：使用try-catch处理异常
    private void readFileWithTryCatch(String filename) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filename);
            int data = fis.read();
            appendOutput("   读取到的数据: " + data);
        } catch (FileNotFoundException e) {
            appendOutput("   文件未找到异常: " + e.getMessage());
        } catch (IOException e) {
            appendOutput("   IO异常: " + e.getMessage());
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                    appendOutput("   文件流已关闭");
                } catch (IOException e) {
                    appendOutput("   关闭文件流时发生错误: " + e.getMessage());
                }
            }
        }
    }
    ```
// 方法2：使用throws声明异常
    private void readFileWithThrows(String filename) throws IOException {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filename);
            int data = fis.read();
            appendOutput("   读取到的数据: " + data);
        } finally {
            if (fis != null) {
                fis.close();
                appendOutput("   文件流已关闭");
            }
        }
    }
    
    // 方法3：问题示例 - 同时使用throws和catch
    private void readFileQuestionable(String filename) throws IOException {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filename);
            int data = fis.read();
            appendOutput("   读取到的数据: " + data);
        } catch (FileNotFoundException e) {
            appendOutput("   文件未找到异常: " + e.getMessage());
            // 这里捕获了异常但没有重新抛出，调用者不知道发生了异常
        } catch (IOException e) {
            appendOutput("   IO异常: " + e.getMessage());
            // 这里捕获了异常但没有重新抛出，调用者不知道发生了异常
        } finally {
            if (fis != null) {
                fis.close(); // 释放资源,可能抛出IOException异常
                appendOutput("   文件流已关闭");
            }
        }
    }
    
    // 方法4：使用try-with-resources（推荐方式）
    ✅ Java 7+ 推荐使用 **try-with-resources** 简化资源管理
    private void readFileWithTryWithResources(String filename) {
        try (FileInputStream fis = new FileInputStream(filename)) {
            int data = fis.read();
            appendOutput("   读取到的数据: " + data);
        } catch (FileNotFoundException e) {
            appendOutput("   文件未找到异常: " + e.getMessage());
        } catch (IOException e) {
            appendOutput("   IO异常: " + e.getMessage());
        }
        // 不需要finally块，资源会自动关闭
        appendOutput("   文件流已自动关闭");
    }

4、常见的异常类型

未检查异常（RuntimeException）

异常 原因
NullPointerException 访问 null 对象的字段或方法
ArrayIndexOutOfBoundsException 数组下标越界
ClassCastException 类型转换错误
IllegalArgumentException 传递了非法参数
NumberFormatException 字符串转数字失败
ArithmeticException 除以零等算术错误

检查异常

异常 原因
IOException 输入输出错误（如文件读写）
FileNotFoundException 文件不存在
SQLException 数据库操作错误
ParseException 字符串解析失败（如日期）

5、自定义异常

当 Java 内置异常无法满足需求时，可以自定义异常。

scala 复制代码 
// 自定义检查异常
public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// 使用
public void setAge(int age) throws InvalidAgeException {
    if (age < 0 || age > 150) {
        throw new InvalidAgeException("年龄必须在 0-150 之间");
    }
    this.age = age;
}

也可以继承 `RuntimeException` 创建未检查异常。
public class InvalidAgeException extends RuntimeException {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public void setAge(int age) {  // 不需要 throws
    if (age < 0 || age > 150) {
        throw new InvalidAgeException("年龄必须在 0-150 之间");
    }
    this.age = age;
}

7、最佳实践与建议

  • 优先使用 try-with-resources 管理资源（如流、连接）
  • 不要捕获所有异常 （避免 catch (Exception e)）
  • 不要忽略异常 （避免空的 catch 块）
  • 记录异常日志 （使用 log.error("msg", e)）
  • 不要在 finally 中使用 return（会覆盖 try 的返回值）
  • 未检查异常应通过代码预防，而不是捕获
  • 检查异常应合理处理或向上抛出

8、 finally中使用return会怎么样？

  • 结论先行：不要在 finally 中使用 return，虽然语法上允许，但 在 finally 中使用 return 是非常危险且不推荐的，原因如下：

    • 如果 finally 块中有 return 语句，会覆盖 try 和 catch 中的返回值
    • 会吞掉异常 （如果 catch 中抛出异常，finally 的 return 会让异常消失）
    • 破坏程序逻辑，难以调试

示例代码

typescript 复制代码 
//1.覆盖try中的return
public static String test() {
    try {
        System.out.println("try block");
        return "from try";
    } finally {
        System.out.println("finally block");
        return "from finally";
    }
}

public static void main(String[] args) {
    System.out.println(test());
}

/*
 `finally` 中的 `return`直接结束方法，返回 "from finally"，原本 `try` 中要返回的 `"from try"` 被丢弃
输出结果：
try block
finally block
from finally
*/

//2.吞掉try中的异常
public static String badExample() {
    try {
        throw new RuntimeException("error");
    } finally {
        return "success"; // 异常被吞了！
    }
}
这个方法不会抛出异常，而是返回 `"success"`，严重掩盖了错误！

//3.特殊情况：try 中有 return，finally 中修改了返回值（针对引用类型）
public static StringBuilder testRef() {
    StringBuilder sb = new StringBuilder("hello");
    try {
        return sb;
    } finally {
        sb.append(", world"); // 修改对象内容
        // 注意：这里没有 return 新值
    }
}
返回值仍然是 `sb`，但内容被修改了，最终结果是 `"hello, world"`。

正确做法：finally 用于清理资源，不要 return

typescript 复制代码 
public static String goodExample() {
    String result = "default";
    try {
        result = "from try";
        return result;
    } finally {
        // 只做资源清理，不要 return
        System.out.println("cleanup resources");
        // ✅ 正确：关闭文件、连接等
        // resource.close();
    }
}
此时返回值是 `"from try"`，`finally` 不影响返回结果。

9、 finally中的代码一定会执行吗？

答案不一定，以前面试美团还是阿里问过，记不清了，finally 块中的代码几乎总是会执行 ，这是 Java 异常处理机制的核心设计之一。它的主要目的就是确保关键的清理操作（如关闭文件、释放资源、断开连接等）能够被执行。

finally 一定会执行的常见情况

示例 ：

csharp 复制代码 
//1.try 中有 return
public static String test() {
    try {
        return "try";
    } finally {
        System.out.println("finally 执行了");
    }
}
//输出：`finally 执行了` → 然后返回 `"try"`

//2.try 中抛出异常
try {
    throw new RuntimeException("error");
} finally {
    System.out.println("finally 还是执行了");
}

//输出：`finally 还是执行了` → 然后抛出异常

finally 不会执行的几种特殊情况

尽管 finally 的设计目标是"无论如何都要执行"，但在以下极少数情况下，它不会执行：

JVM 退出或崩溃

如果在 try 或 catch 中调用了 System.exit(0) 或 Runtime.getRuntime().halt()，JVM 直接终止，finally 不会执行。

csharp 复制代码 
try {
    System.out.println("try");
    System.exit(0); // JVM 退出
} finally {
    System.out.println("finally"); // ❌ 不会执行！
}

线程在 try/catch 中被强制终止

  • 如果线程在 try 或 catch 中被 Thread.stop()（已废弃）或 interrupt() 强行中断，且导致 JVM 不正常运行，finally 可能不会执行。
  • 虽然 interrupt() 本身不会阻止 finally 执行，但如果线程状态异常，可能影响执行。

3. JVM 崩溃或操作系统故障

  • 如发生严重错误（OutOfMemoryError、StackOverflowError 等）导致 JVM 崩溃。
  • 或操作系统死机、断电等硬件/系统级故障。
csharp 复制代码 
try {
    while (true) {
        // 无限循环占满 CPU，可能导致系统无响应
    }
} finally {
    System.out.println("finally"); // ❌ 可能永远不执行
}

在 finally 之前发生 native 代码死锁或无限循环

  • 如果 try 块中调用了 native 方法（JNI），并且该方法陷入死锁或无限循环，JVM 无法继续执行 finally。

finally 块在绝大多数情况下都会执行 ，这是它设计的初衷。finally 的承诺是："只要 JVM 还活着，并且程序能继续运行，我就会执行。

9、什么是 try-with-resources？

try-with-resources 是一种特殊的 try 语句，它允许你声明一个或多个资源 ，并在 try 块执行完毕后自动关闭这些资源，无论是否发生异常。

✅ 核心目标：自动、安全地释放资源（如文件流、网络连接、数据库连接等）。

基本语法

csharp 复制代码 
try (资源声明) {
    // 使用资源
} catch (ExceptionType e) {
    // 处理异常（可选）
} finally {
    // 清理代码（可选）
}

前提条件：资源必须实现 AutoCloseable 接口

Java 中常见的可关闭资源都实现了 AutoCloseable 或其子接口 Closeable：

  • InputStream / OutputStream
  • Reader / Writer
  • Socket
  • Connection（数据库连接）
  • Statement / ResultSet

示例对比：传统方式 vs try-with-resources

ini 复制代码 
//1.传统方式（繁琐且易出错）
FileInputStream fis = null;
try {
    fis = new FileInputStream("data.txt");
    int data = fis.read();
    System.out.println(data);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close(); // 必须手动关闭，且 close() 也可能抛异常
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//问题：代码冗长，容易忘记关闭资源，`close()` 异常需要额外处理

//2. ✅ 使用 try-with-resources（简洁安全）
try (FileInputStream fis = new FileInputStream("data.txt")) {
    int data = fis.read();
    System.out.println(data);
} catch (IOException e) {
    e.printStackTrace();
}
//无需手动调用 `close()` ，JVM 会自动调用！

//3.多个资源的使用
try (
    FileInputStream fis = new FileInputStream("input.txt");
    FileOutputStream fos = new FileOutputStream("output.txt")
) {
    int data;
    while ((data = fis.read()) != -1) {
        fos.write(data);
    }
} catch (IOException e) {
    e.printStackTrace();
}
//多个资源用分号 `;` 分隔，关闭顺序是**声明的逆序**（先 `fos`，再 `fis`）。

资源是如何自动关闭的？

  1. try 块执行完毕（正常结束或抛出异常）
  2. JVM 自动调用每个资源的 close() 方法
  3. 关闭顺序：从最后一个声明的资源开始，逆序关闭
  4. 如果 close() 抛出异常，它会被抑制（suppressed） ，主异常(try块中的异常)仍然会被抛出

异常处理机制（重要！）

如果 try 块和 close() 都抛出异常，主异常是 try 块中的异常 ，close() 的异常会被"抑制"，但可以通过 getSuppressed() 获取。

php 复制代码 
try (MyResource res = new MyResource()) {
    throw new RuntimeException("try 块异常");
} catch (Exception e) {
    System.out.println("主异常: " + e.getMessage());
    for (Throwable t : e.getSuppressed()) {
        System.out.println("被抑制的异常: " + t.getMessage());
    }
}

自定义可关闭资源

你可以创建自己的 AutoCloseable 资源：

csharp 复制代码 
public class MyResource implements AutoCloseable {
    public MyResource() {
        System.out.println("资源打开");
    }

    public void doWork() {
        System.out.println("执行任务");
    }

    @Override
    public void close() throws Exception {
        System.out.println("资源关闭");
    }
}

// 使用
try (MyResource res = new MyResource()) {
    res.doWork();
}


输出：
资源打开
执行任务
资源关闭

总结

项目 说明
目的 自动管理资源，避免资源泄漏
要求 资源必须实现 AutoCloseable 或 Closeable
优点 代码简洁、安全、不易出错
适用场景 所有需要手动关闭的资源（I/O、数据库、网络等）
Java 版本 Java 7+

💡 一句话理解 ：
try-with-resources 就像是"用完即扔 "的智能容器------你只管使用资源，JVM 会在 try 块结束后自动帮你关闭它，无论是否发生异常。

相关推荐
崎岖Qiu18 分钟前
【设计模式笔记06】：单一职责原则
java·笔记·设计模式·单一职责原则
Hello.Reader24 分钟前
Flink ExecutionConfig 实战并行度、序列化、对象重用与全局参数
java·大数据·flink
熊小猿1 小时前
在 Spring Boot 项目中使用分页插件的两种常见方式
java·spring boot·后端
paopaokaka_luck1 小时前
基于SpringBoot+Vue的助农扶贫平台（AI问答、WebSocket实时聊天、快递物流API、协同过滤算法、Echarts图形化分析、分享链接到微博）
java·vue.js·spring boot·后端·websocket·spring
老华带你飞1 小时前
机器人信息|基于Springboot的机器人门户展示系统设计与实现(源码+数据库+文档)
java·数据库·spring boot·机器人·论文·毕设·机器人门户展示系统
notion20252 小时前
Adobe Lightroom Classic下载与安装教程（附安装包） 2025最新版详细图文安装教程
java·数据库·其他·adobe
rengang662 小时前
351-Spring AI Alibaba Dashscope 多模型示例
java·人工智能·spring·多模态·spring ai·ai应用编程
小蒜学长3 小时前
springboot酒店客房管理系统设计与实现（代码+数据库+LW）
java·数据库·spring boot·后端
橙子家3 小时前
Serilog 日志库简单实践（一）：文件系统 Sinks（.net8）
后端
lang201509283 小时前
Spring MVC配置全解析
java·spring·mvc
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Labelme从安装到标注：零基础完整指南09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）