Java 异常处理全解析：从基础到自定义异常的实战指南

一、Java 异常体系：Error 与 Exception 的本质区别

1. 异常体系核心架构

Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

Java 异常体系基于Throwable类，分为两大分支：

Throwable
├─ Error（错误）
│  └─ 例：OutOfMemoryError、StackOverflowError
└─ Exception（异常）
   ├─ Checked Exception（编译时异常）
   │  └─ 例：IOException、SQLException
   └─ Unchecked Exception（运行时异常）
      └─ 例：NullPointerException、ArrayIndexOutOfBoundsException

在这里插入图片描述

2.什么是异常以及异常的简单分类

异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间,它影响了正常的程序执行流程。

要理解java异常处理是如何工作的，你需要掌握以下三种类型的异常Exception：

检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误Error: 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

3. Error vs Exception

Error和Exception的区别:Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

维度	Error	Exception
本质	JVM 底层错误，不可恢复	程序运行中的异常情况
处理方式	无法捕获，需重启 JVM	可捕获处理或声明抛出
典型场景	内存溢出、类加载失败	空指针、数组越界、用户输入错误

4. Checked vs Unchecked 异常

Checked 异常：

必须显式处理（捕获或声明抛出）
示例：文件读取时的FileNotFoundException

try {
    FileReader reader = new FileReader("file.txt");
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

Unchecked 异常：

无需强制处理（运行时检查）
示例：参数校验失败的IllegalArgumentException

public void checkAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数");
    }
}

二、异常处理核心机制：捕获与抛出

1. 异常捕获语法（try-catch-finally）

try {
    // 可能抛出异常的代码
    int result = 10 / 0; // 抛出ArithmeticException
} catch (ArithmeticException e) { // 捕获具体异常
    System.out.println("错误原因：" + e.getMessage()); // 输出：/ by zero
    e.printStackTrace(); // 打印堆栈跟踪信息
} catch (Exception e) { // 父类异常捕获（需放在最后）
    // 通用异常处理
} finally {
    // 可选：无论是否异常都会执行（常用于资源释放）
    System.out.println("执行finally块");
}

2. 异常抛出关键字

throw（方法内抛出异常实例）

public static int divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("除数不能为0"); // 主动抛出异常
    }
    return a / b;
}

throws（方法声明抛出异常）

public static void readFile(String path) throws FileNotFoundException {
    FileReader reader = new FileReader(path); // 声明抛出Checked异常
}

3. 异常处理顺序原则

子类异常优先：具体异常（如FileNotFoundException）需写在父类异常（如IOException）之前
finally 的绝对性：即使 try 块中有return，finally 仍会执行（但返回值会被缓存）

4.本节狂神说笔记

package com.exception;

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        //假设要捕获多个异常： 从小到大！

        try {//try监控区域
            System.out.println(a/b);
        } catch (Error e) {//catch（想要捕获的异常类型！）捕获异常
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {//处理善后工作
            System.out.println("finally");
        }

        finally 可以不要finally, 假设I0，资源，关闭!
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

package com.exception;

public class Test2 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        //Ctrl Alt + T
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        } finally {
        }
    }
}

package com.exception;

public class Test1 {
    public static void main(String[] args) {
        try {
            new Test1().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b == 0){//throw  throws
            throw new ArithmeticException();//主动的抛出异常，一般在方法中使用
        }
    }
}

三、自定义异常：打造业务专属错误体系

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

1. 自定义异常类步骤

创建自定义异常类。
在方法中通过throw关键字抛出异常对象。
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
在出现异常方法的调用者中捕获并处理异常。

步骤 1：继承 Exception 或 RuntimeException

// Checked异常（需显式处理）
public class UserAgeException extends Exception {
    public UserAgeException(String message) {
        super(message); // 调用父类构造器
    }
}

// Unchecked异常（运行时异常）
public class InvalidInputException extends RuntimeException {
    public InvalidInputException(String message) {
        super(message);
    }
}

步骤 2：在业务逻辑中抛出

public void validateUser(int age) throws UserAgeException {
    if (age < 18) {
        throw new UserAgeException("用户年龄必须≥18岁"); // 抛出自定义Checked异常
    }
}

2. 异常处理最佳实践

（1）异常信息规范

包含足够上下文："用户ID为" + userId + "的账户不存在"
避免裸露捕获Exception：应捕获具体异常类型

（2）资源释放最佳实践

// JDK 7+ 自动资源管理（替代finally）
try (FileReader reader = new FileReader("file.txt")) {
    // 自动关闭资源（无需显式finally）
} catch (IOException e) {
    // 处理文件读取异常
}

（3）异常链使用

try {
    // 业务逻辑
} catch (ServiceException e) {
    throw new ControllerException("接口调用失败", e); // 包装异常链
}

3.实际应用中的经验总结

处理运行时异常时，采用逻辑去合理规避同时辅助 try-catch 处理
在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
对于不确定的代码，也可以加上 try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单地调用 printStackTrace()去打印输出
具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加finally语句块去释放占用的资源

四、常见异常处理错误与解决方案

1. 空指针异常（NPE）

错误示例：

String str = null;
int length = str.length(); // 抛出NullPointerException

解决方案：

if (str != null) {
    int length = str.length();
} else {
    throw new IllegalArgumentException("字符串不可为null");
}

2. 未处理 Checked 异常

错误示例：

public void readFile() {
    FileReader reader = new FileReader("file.txt"); // 编译错误：未处理IOException
}

解决方案：

// 方案1：捕获处理
try { /* ... */ } catch (IOException e) { /* ... */ }

// 方案2：声明抛出
public void readFile() throws IOException { /* ... */ }

3. finally 中的 return 陷阱

错误示例：

public static int testFinally() {
    try {
        return 1;
    } finally {
        return 2; // 最终返回2，覆盖try中的return
    }
}

正确做法：

public static int testFinally() {
    int result = 1;
    try {
        return result;
    } finally {
        result = 2; // 不建议在finally中使用return
    }
}