Java异常体系从误区到精通深度解析

int x = "hello";  // ？

┌─────────────────────────────────────────────────────┐
│                    你说"编译异常"的时候               │
│                    到底指的是哪一个？                  │
│                         │                           │
│          ┌──────────────┴──────────────┐            │
│          │                             │            │
│          ▼                             ▼            │
│  语法编译报错                    编译时受检异常       │
│  (syntax error)              (checked exception)    │
│          │                             │            │
│          ▼                             ▼            │
│  代码不合法，javac               代码合法，javac      │
│  拒绝编译，不给生成              能编译通过，但强制   │
│  .class 文件                   要求处理潜在风险       │
└─────────────────────────────────────────────────────┘

// 例 1：类型不匹配
int x = "hello";        // ❌ incompatible types: string cannot be converted to int

// 例 2：缺少分号
system.out.println(1)   // ❌ ';' expected

// 例 3：变量未声明
system.out.println(y);  // ❌ cannot find symbol: variable y

// 例 4：调用不存在的方法
"hello".fly();           // ❌ cannot find symbol: method fly()

// 例：filereader 的构造器声明了 throws ioexception
filereader fr = new filereader("test.txt");
// ❌ 编译报错：unreported exception java.io.filenotfoundexception;
//              must be caught or declared to be thrown

java.lang.throwable
    │
    ├── java.lang.error                          ← jvm 内部故障
    │       ├── virtualmachineerror
    │       │       ├── outofmemoryerror          ← 堆内存耗尽
    │       │       ├── stackoverflowerror        ← 调用栈溢出（无限递归）
    │       │       └── internalerror             ← jvm 内部实现错误
    │       ├── linkageerror
    │       │       ├── noclassdeffounderror      ← 编译时有，运行时找不到类
    │       │       ├── nosuchmethoderror         ← 编译时有，运行时找不到方法
    │       │       └── classformaterror          ← .class 文件损坏
    │       └── assertionerror                    ← 断言失败
    │
    └── java.lang.exception                       ← 程序可以干预
            │
            ├── runtimeexception                 ← 运行时异常（unchecked）
            │       ├── nullpointerexception
            │       ├── arithmeticexception       ← 除零
            │       ├── arrayindexoutofboundsexception
            │       ├── classcastexception
            │       └── illegalargumentexception
            │
            └── 其他 exception                    ← 受检异常（checked）
                    ├── ioexception
                    │       └── filenotfoundexception
                    ├── sqlexception
                    ├── classnotfoundexception
                    └── interruptedexception

// ❌ 反模式：试图"吞掉并恢复"
try {
    deeprecursion();  // 可能 stackoverflowerror
} catch (error e) {
    system.out.println("没事，继续跑");  // 自欺欺人！
}

// ✅ 仅在最外层，记录日志后退出
public static void main(string[] args) {
    try {
        startapplication();
    } catch (error e) {
        // 仅记录日志，不尝试恢复
        logger.fatal("jvm 发生严重故障，程序即将退出", e);
        system.exit(1);
    }
}

string s = null;
int len = s.length();

java 层：                jvm c++ 层（hotspot）：
                         
s.length()    ──────→   判断 s == null ？
                              │
                    ┌─────────┴──────────┐
                    │                    │
                    ▼                    ▼
                 是 null              不是 null
                    │                    │
                    ▼                    ▼
              c++ 代码直接          正常调用方法，
              创建并抛出            返回结果
              nullpointerexception
              对象（java 类型）

// 这不是真实源码，但逻辑等价
if (receiver == null) {
    // 在 c++ 层创建 java 的 nullpointerexception 对象
    // 然后抛给 java 层
    throw(vmsymbols::java_lang_nullpointerexception());
}

int[] arr = new int[4];
arr[4] = 1;  // arrayindexoutofboundsexception

if (index < 0 || index >= array->length()) {
    throw(vmsymbols::java_lang_arrayindexoutofboundsexception());
}

int x = 1 / 0;  // arithmeticexception

┌───────────────────────────────────────────────────────┐
│  部分 runtimeexception 的抛出者：jvm c++ 实现           │
│  （npe、数组越界、除零、classcastexception）             │
│  异常类的 java 定义：提供构造函数、栈轨迹填充等完整功能    │
│  真正判断"什么时候该抛"的逻辑：在 c++ 的 hotspot jvm 里   │
│                                                       │
│  另一部分 runtimeexception 由 java 代码主动 throw        │
│  （illegalargumentexception、numberformatexception 等） │
└───────────────────────────────────────────────────────┘

// ❌ 编译不通过
filereader fr = new filereader("test.txt");

// 编译器错误：
// unreported exception java.io.filenotfoundexception;
// must be caught or declared to be thrown

// filereader 构造器的源码声明（简化）
public class filereader extends inputstreamreader {

    public filereader(string filename) throws filenotfoundexception {
        super(new fileinputstream(filename));
    }
}

new filereader("test.txt")

// 受检异常：必须处理
public void readfile() throws ioexception {   // 必须声明
    filereader fr = new filereader("test.txt");
}

// 运行时异常：不需要声明
public void divide() {                         // 不用声明
    int x = 1 / 0;  // 可能抛出 arithmeticexception(runtimeexception 的子类)
}

// 运行时异常——空指针。正确的做法是：
// ❌ 不要这样：
try {
    s.length();
} catch (nullpointerexception e) {
    // 吞掉异常 —— 这是最烂的做法
}

// ✅ 应该这样：
if (s != null) {
    s.length();
} else {
    // 处理 null 逻辑，或者确保 s 永远不会是 null
}

// c 风格 —— 用返回值判断成功/失败
public class filereader {
    // 返回 0 表示失败，1 表示成功
    public int read(char[] buffer) {
        // ...
    }
}

// 调用方：
filereader fr = new filereader("test.txt");
char[] buf = new char[1024];
int result = fr.read(buf);
if (result == 0) {
    // 处理读取失败...
}

// ❌ 如果不用异常，解析字符串为 int：
int num = integer.parseint("abc");
// 怎么表示"解析失败"？返回 null？—— int 不能是 null
// 返回 -1？—— 那 "-1" 这个合法输入怎么办？
// 返回 optional？—— 代码立刻变得冗长

// c 风格：每层都要检查并传递错误码
int a() {
    int result = b();
    if (result == -1) return -1;
    // 正常逻辑...
    int result2 = c();
    if (result2 == -1) return -1;
    // 正常逻辑...
    return 0;
}

// java 风格：异常自动穿越调用栈
void a() throws ioexception {
    b();  // b() 失败了？异常自动往上冒，a() 不用写任何传递代码
    c();
}

// 构造器的返回值类型是"没有"
// 你不能写：
person p = new person("张三", -5);  // age 不合法
if (p.isinvalid()) { ... }  // ← 这不是构造器能做的

// 唯一的方式就是抛异常，拒绝创建
public person(string name, int age) {
    if (age < 0) {
        throw new illegalargumentexception("年龄不能为负数");  // ← 异常是唯一出口
    }
    this.age = age;
}

// if 检查是轻量级的，不会生成异常对象，不会生成栈轨迹
if (index >= 0 && index < arr.length) {
    return arr[index];
}
// vs
try {
    return arr[index];
} catch (arrayindexoutofboundsexception e) { ... }
// try-catch 版本在真的抛异常时，代价巨大（生成栈轨迹）

// 业务层面：年龄不能为负数
public void setage(int age) {
    if (age < 0) {
        // jvm 不会自动判断这个。对 jvm 来说，int = -5 完全合法
        throw new illegalargumentexception("年龄不能为负数: " + age);
    }
    this.age = age;
}

// 业务层面：取款金额不能超过余额
public void withdraw(double amount) {
    if (amount > balance) {
        // jvm 不知道你的业务规则
        throw new insufficientbalanceexception("余额不足");
    }
    balance -= amount;
}

┌───────────────────────────────────────────────────────┐
│                     异常来源分布                        │
│                                                       │
│  jvm 自动抛（机器语义）         手动 throw（业务语义）    │
│  ──────────────────────        ───────────────────    │
│  nullpointerexception          illegalargumentexception│
│  arrayindexoutofbounds         illegalstateexception  │
│  arithmeticexception           自定义业务异常          │
│  classcastexception                                   │
│                                                       │
│  覆盖范围：                                                    │
│  ├── 内存/指针/类型安全        ├── 业务规则校验        │
│  └── 约 30% 的异常场景         └── 约 70% 的异常场景   │
└───────────────────────────────────────────────────────┘

拿到一个异常，问自己：
├── 是写错代码就会触发的？（空指针、越界、除零、类型转换错）
│   └── → jvm 自动抛。你应该修代码，不应该 catch。
│
├── 是 jdk/第三方库方法内部判断后抛的？
│   └── → 代码主动抛。你要看它的方法签名，决定 try-catch 还是 throws。
│
└── 是你自己定义并 throw 的？
    └── → 代码主动抛。你负责声明 throws 或在上层 catch。

// 你有两个版本的 lib：
// lib v1.0:   class user { public string getname() { ... } }
// lib v2.0:   class user { public string getfullname() { ... } }  // getname 被删了

// 你的代码用 v1.0 编译，调用 getname()
// 运行时 classpath 上却是 v2.0 的 jar
// 结果：
// exception in thread "main" java.lang.nosuchmethoderror:
//     com.example.user.getname()ljava/lang/string;

exception 的语义：程序可以也应该 try-catch 处理
→ 方法不存在，你怎么处理？重新下载正确版本的 jar 吗？还是自己实现一个？
→ 哪种都不合理。这是部署/依赖管理的错误，不是程序逻辑的错误。

error 的语义：jvm 遇到无法继续正常运行的情况
→ 编译时存在的方法，运行时消失了 → 类版本不一致
→ 这说明运行时环境本身就是错的，程序不应该试图"恢复"

linkageerror（链接错误）
├── noclassdeffounderror      ← 编译时有 .class，运行时类路径上找不到
├── nosuchmethoderror         ← 编译时有方法签名，运行时类中没有
├── classformaterror          ← .class 文件损坏或被篡改
├── unsatisfiedlinkerror      ← native 方法对应的 .so/.dll 找不到
└── exceptionininitializererror ← static {} 初始化块抛异常导致类加载失败

                    ┌──────────────────────────┐
        第 1 层     │   if 预判（能避免就不要抛）   │  ← 性能最好，处理"常态分支"
                    └──────────┬───────────────┘
                               │ if 预判兜不住
                               ▼
                    ┌──────────────────────────┐
        第 2 层     │   throw 抛出（快速失败）     │  ← 明确拒绝非法状态
                    └──────────┬───────────────┘
                               │ 异常沿调用栈冒泡
                               ▼
                    ┌──────────────────────────┐
        第 3 层     │   try-catch 兜底（统一处理） │  ← 在最外层统一捕获和处理
                    └──────────────────────────┘

// ❌ 不好：用异常控制正常流程
try {
    return list.get(index);
} catch (indexoutofboundsexception e) {
    return null;
}

// ✅ 好：if 预判
if (index >= 0 && index < list.size()) {
    return list.get(index);
}
return null;

// ✅ 好：参数不合法，立刻 throw
public void transfer(account from, account to, double amount) {
    if (from == null) {
        throw new illegalargumentexception("转出账户不能为 null");
    }
    if (to == null) {
        throw new illegalargumentexception "转入账户不能为 null");
    }
    if (amount <= 0) {
        throw new illegalargumentexception("转账金额必须大于 0");
    }
    if (from.getbalance() < amount) {
        throw new insufficientbalanceexception("余额不足");
    }
    if (from.equals(to)) {
        throw new illegalargumentexception("不能给自己转账");
    }

    // 所有校验通过，执行转账
    from.debit(amount);
    to.credit(amount);
}

// ❌ 不好：过早 catch，信息丢失
public void processfile() {
    try {
        string content = readfile("data.txt");
    } catch (ioexception e) {
        e.printstacktrace();  // 打印完继续跑 —— 什么都没解决
    }
}

// ✅ 好：在最外层统一 catch，做有意义的处理
// controller 层（spring mvc）：
@restcontrolleradvice
public class globalexceptionhandler {

    @exceptionhandler(ioexception.class)
    public responseentity<errorresponse> handleio(ioexception e) {
        logger.error("文件操作失败", e);
        // 1. 记录完整日志（含请求参数、用户信息）
        // 2. 返回对用户友好的错误信息
        return responseentity.status(500)
            .body(new errorresponse("系统繁忙，请稍后重试"));
    }

    @exceptionhandler(illegalargumentexception.class)
    public responseentity<errorresponse> handleillegalarg(illegalargumentexception e) {
        return responseentity.status(400)
            .body(new errorresponse(e.getmessage()));
    }
}

// ✅ 好：先 catch 具体异常，最后 catch 宽泛异常
try {
    // 业务操作
    database.save(data);
    file.write(data);
    messagequeue.send(data);
} catch (sqlexception e) {
    // 数据库特定处理：可以尝试重连
    logger.error("数据库异常", e);
} catch (ioexception e) {
    // 文件特定处理：可以尝试备用路径
    logger.error("文件异常", e);
} catch (exception e) {
    // 兜底：记录并告警
    logger.error("未知异常", e);
    throw new serviceexception("处理失败", e);  // 包装后重新抛出
}

// ❌ 不好：丢失原始异常
try {
    db.save(data);
} catch (sqlexception e) {
    throw new serviceexception("保存失败");  // 原始 sqlexception 丢了！
}

// ✅ 好：保留原始异常链
try {
    db.save(data);
} catch (sqlexception e) {
    throw new serviceexception("保存用户数据失败", e);  // e 作为 cause 传入
}

// 排查时可以追溯到根因：
// serviceexception: 保存用户数据失败
// caused by: sqlexception: duplicate entry 'zhangsan' for key 'username'

// ============ service 层 ============
public class userservice {

    public user createuser(string username, string email, int age) {
        // 第 1 层：if 预判参数合法性
        if (username == null || username.isblank()) {
            throw new illegalargumentexception("用户名不能为空");
        }
        if (email == null || !email.contains("@")) {
            throw new illegalargumentexception("邮箱格式不正确");
        }
        if (age < 0 || age > 150) {
            throw new illegalargumentexception("年龄范围为 0-150");
        }

        // 第 2 层：if 预判业务状态
        if (userrepository.existsbyusername(username)) {
            throw new businessexception("用户名已被占用");
        }

        // 第 3 层：通过 try-catch 处理外部依赖异常
        try {
            return userrepository.save(new user(username, email, age));
        } catch (dataaccessexception e) {
            logger.error("创建用户失败: username={}", username, e);
            throw new serviceexception("用户创建失败，请稍后重试", e);
        }
    }
}

// ============ controller 层（统一异常处理） ============
@restcontrolleradvice
public class globalexceptionhandler {

    @exceptionhandler(illegalargumentexception.class)
    public responseentity<errorresponse> handle400(illegalargumentexception e) {
        return responseentity.badrequest()
            .body(new errorresponse("参数错误", e.getmessage()));
    }

    @exceptionhandler(businessexception.class)
    public responseentity<errorresponse> handle409(businessexception e) {
        return responseentity.status(409)
            .body(new errorresponse("业务冲突", e.getmessage()));
    }

    @exceptionhandler(serviceexception.class)
    public responseentity<errorresponse> handle500(serviceexception e) {
        return responseentity.status(500)
            .body(new errorresponse("系统错误", "请稍后重试"));
    }

    @exceptionhandler(exception.class)
    public responseentity<errorresponse> handleunknown(exception e) {
        logger.error("未预期的异常", e);  // 这种是真正的 bug，需要修
        return responseentity.status(500)
            .body(new errorresponse("系统错误", "未知错误"));
    }
}

                          throwable
                              │
              ┌───────────────┴───────────────┐
              │                               │
           error                          exception
        (jvm故障)                        (程序可干预)
        不要catch                              │
                                              │
                    ┌─────────────────────────┴──────────────────┐
                    │                                            │
            runtimeexception                          受检异常 (checked)
           (运行时异常/unchecked)                     (编译器强制处理)
                    │                                            │
        ┌───────────┼───────────┐              ┌─────────┼──────────┐
        │           │           │              │         │          │
    npe     越界异常    除零异常       ioexception  sqlexception  ...
        │           │           │
        └───────────┴───────────┘
                    │
        npe/越界/除零/cce → jvm c++ 触发
        iae/npe（主动）/ise → java 代码主动 throw