关于 java：4. 异常处理与调试

一、异常核心语法

1.1 try-catch-finally：异常捕获与处理结构

1）作用

• 用于捕获和处理程序运行过程中可能发生的异常

• 防止程序因异常中断，提高代码的鲁棒性（健壮性）

2）基本语法结构：

try {
    // 可能抛出异常的代码块
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 无论是否发生异常，都会执行（如关闭资源）
}

3）示例讲解：

public class Demo {
    public static void main(String[] args) {
        try {
            int a = 10 / 0; // 运行时异常：ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("错误：除数不能为零！");
        } finally {
            System.out.println("程序结束，释放资源。");
        }
    }
}

运行结果：

错误：除数不能为零！
程序结束，释放资源。

4）多个 catch：

try {
    String s = null;
    System.out.println(s.length());
} catch (NullPointerException e) {
    System.out.println("空指针异常！");
} catch (Exception e) {
    System.out.println("其他异常：" + e.getMessage());
}

建议先写具体异常，再写父类（Exception），否则子类异常无法被捕获。

5）finally 详解

• 无论 try 块是否抛出异常，finally 总会执行

• 通常用于释放资源，如关闭文件、数据库连接

FileInputStream fis = null;
try {
    fis = new FileInputStream("data.txt");
    // 读取文件
} catch (IOException e) {
    System.out.println("读取失败");
} finally {
    if (fis != null) {
        try {
            fis.close(); // 一定要关闭资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.2 throw：手动抛出异常对象

1）作用

throw 用于在代码中主动抛出一个异常实例，可以抛出任何 Throwable 的子类。

2）语法格式：

throw new 异常类型("异常描述");

3）示例：

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

• 程序执行到 throw 语句时会立即抛出异常并中断执行

• 如果这个异常没有在方法内被 try-catch 捕获，必须用 throws 声明

1.3 throws：方法声明异常

1）作用

• 用于方法签名中，声明该方法可能抛出哪些异常

• 告诉调用者：你要么用 try-catch 处理，要么继续 throws 抛

2）语法格式：

返回类型 方法名(...) throws 异常类型1, 异常类型2 {
    // 可能抛出异常的代码
}

3）示例：

public void readFile(String path) throws IOException {
    FileReader fr = new FileReader(path); // FileReader 会抛 IOException
}

调用时：

try {
    readFile("test.txt");
} catch (IOException e) {
    System.out.println("文件读取失败：" + e.getMessage());
}

4）throw vs throws 区别对比表：

特性	throw	throws
用途	抛出异常对象	声明异常可能被抛出
位置	方法体内	方法声明处
后面跟的内容	异常对象（new）	异常类（不带 new）
示例	throw new IOException("失败")	throws IOException

1.4 综合例子：使用 throw + throws + try-catch

public class User {
    public void login(String username) throws Exception {
        if (username == null || username.isEmpty()) {
            throw new Exception("用户名不能为空");
        }
        System.out.println("登录成功");
    }

    public static void main(String[] args) {
        User user = new User();
        try {
            user.login(""); // 会抛出异常
        } catch (Exception e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("登录尝试结束");
        }
    }
}

输出：

捕获到异常: 用户名不能为空
登录尝试结束

1.5 实际用法

场景	应用
开发中	用 try-catch 处理用户输入、文件读取等不确定行为
SDK 调试	通过日志堆栈 catch (Exception e) 观察调用流程
逆向分析中	Hook 异常处理函数，绕过 throw 抛出的错误（例如：校验失败）
安全测试中	利用错误提示、异常堆栈进行路径发现或代码注入入口分析

1.6 小结

try-catch-finally
│
├─ try：放入可能出错的代码
├─ catch：处理指定异常类型
├─ finally：一定执行，用于释放资源
│
throw：主动抛出异常对象
throws：方法声明可能抛出哪些异常

---

二、自定义异常类

2.1 自定义异常类的作用

在 Java 中，除了使用系统提供的异常（如 NullPointerException, IOException），我们还可以根据自己的业务逻辑需求定义新的异常类。

自定义异常的典型用途：

• 表示业务逻辑错误（例如：余额不足、权限异常）

• 抛出更清晰可读、可追踪的错误

• 与项目的模块/组件解耦，提高代码可维护性

• 在调试或逆向中，定位异常的抛出源

2.2 自定义异常类的本质

Java 中所有异常类，最终都继承自：

java.lang.Throwable
    ├── Error         // 错误（虚拟机错误等）
    └── Exception     // 异常
         ├── RuntimeException（运行时异常）
         └── 其他受检异常（IOException 等）

我们自定义的异常通常继承自：

1）Exception（受检异常）

• 必须用 try-catch 或 throws 处理

2）RuntimeException（非受检异常）

• 编译器不强制捕获

• 更灵活，适合应用内部逻辑异常

2.3 自定义异常类的语法

1）继承 Exception（受检异常）

public class MyCheckedException extends Exception {
    public MyCheckedException() {
        super();
    }

    public MyCheckedException(String message) {
        super(message);
    }

    public MyCheckedException(String message, Throwable cause) {
        super(message, cause);
    }
}

2）继承 RuntimeException（非受检异常）

public class MyRuntimeException extends RuntimeException {
    public MyRuntimeException(String message) {
        super(message);
    }
}

2.4 使用自定义异常的例子

示例 1：余额不足异常

// 自定义异常类
public class InsufficientBalanceException extends Exception {
    public InsufficientBalanceException(String message) {
        super(message);
    }
}

示例 2：在业务代码中使用

public class BankAccount {
    private double balance = 100.0;

    public void withdraw(double amount) throws InsufficientBalanceException {
        if (amount > balance) {
            throw new InsufficientBalanceException("余额不足，取款失败！");
        }
        balance -= amount;
    }
}

示例 3：调用者处理异常

public class Test {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        try {
            account.withdraw(150.0); // 触发异常
        } catch (InsufficientBalanceException e) {
            System.out.println("异常捕获：" + e.getMessage());
        }
    }
}

2.5 规范建议（编写自定义异常）

建议项	内容
类名	以 Exception 结尾（如 LoginFailedException）
构造方法	提供 String message、Throwable cause 构造器
继承方式	业务类建议继承 Exception，内部错误建议继承 RuntimeException
包名	放在 com.xxx.exception 包下，统一管理

2.6 自定义异常在调试/逆向中的价值

在调试中：

• 通过日志或堆栈跟踪定位自定义异常的抛出点

• 比系统异常更具语义性，便于快速理解错误

在逆向中：

• 某些 SDK 或加密逻辑会用自定义异常抛出校验错误

• 通过 Frida/日志/trace 定位异常类名和抛出位置

• 分析异常触发条件，进而绕过或构造伪装数据

2.7 小结

自定义异常类
├─ 为什么要自定义？
├─ 继承 Exception / RuntimeException
├─ 如何定义：构造器 + 命名规范
├─ 如何使用：抛出 throw + 声明 throws
├─ 实际场景：业务逻辑错误、逆向定位

---

三、常见异常类型

3.1 NullPointerException（空指针异常）

1）定义

空指针异常是指：访问了一个为 null 的引用对象的方法或字段时引发的异常。

java.lang.NullPointerException

2）常见触发场景

触发语句	说明
obj.toString()	obj 为 null，调用方法抛异常
obj.field	访问成员变量时，obj 为 null
arr[0]	arr 是 null，访问数组元素抛异常
list.get(0)	list 是 null，而非空但索引越界时会抛 IndexOutOfBoundsException

3）示例代码

public class Demo {
    public static void main(String[] args) {
        String s = null;
        System.out.println(s.length()); // NullPointerException
    }
}

4）调试方式

• 查看异常栈信息（Exception stack trace）

• 从堆栈中定位异常行号和方法名

• 使用 IDE 的断点或日志逐步排查 null 来源

栈追踪示例：

Exception in thread "main" java.lang.NullPointerException
    at Demo.main(Demo.java:4)

5）如何防止空指针

方法	示例
非空判断	if (obj != null)
Optional	Optional.ofNullable(obj).orElse(defaultValue)
IDE 工具提醒	IntelliJ IDEA 有 null 检测功能
Lombok 的 @NonNull 注解	编译时校验是否为 null

3.2 ClassCastException（类强制类型转换异常）

1）定义

该异常表示：试图将某个对象强制转换为不是其实际类型的类时引发的异常。

java.lang.ClassCastException

2）常见触发场景

Object obj = new Integer(5);
String str = (String) obj; // 报 ClassCastException

虽然 obj 是 Object 类型，但实际它是 Integer，不能强制转成 String。

3）示例代码

public class Demo {
    public static void main(String[] args) {
        Object obj = "Hello";
        Integer num = (Integer) obj; // ClassCastException
    }
}

输出异常信息：

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at Demo.main(Demo.java:4)

4）如何避免 ClassCastException

方法	示例
使用 instanceof 判断	if (obj instanceof Integer)
使用泛型（推荐）	List 比 List
明确接口和实现类边界	不随意强转接口实现
开发规范约束	明确参数传递和接收类型

3.3 调试角度分析

异常类型	常见错误栈信息	调试关键点
NullPointerException	指向具体行的空对象访问	追踪为 null 的变量，检查赋值
ClassCastException	指出无法转换的两个类	看实际对象的类型（getClass()）和要转的类

3.4 在逆向/安全分析中的价值

1）辅助分析代码结构

• App crash 日志中出现 ClassCastException 可能表示有 代码逻辑混淆或伪装

• 出现 NullPointerException 时，反编译代码可定位关键对象未初始化

2）模拟异常绕过检查

try {
    if (!licenseValid) {
        throw new NullPointerException("验证失败");
    }
} catch (Exception e) {
    // 验证失败后中断
    return;
}

可以 Hook 掉这个 throw，或者强改 licenseValid 为 true，绕过验证。

3.5 小结

异常	本质	触发时机	预防方法
NullPointerException	空引用访问	访问 null 的变量、方法或数组	非空检查、Optional
ClassCastException	类型错误	强转成非实际类型	instanceof 判断、泛型

---

四、堆栈追踪分析

4.1 什么是堆栈追踪（Stack Trace）？

堆栈追踪是 Java 程序在运行中发生异常或错误时，JVM 自动打印的一系列方法调用栈信息，描述了从异常发生点逐层向上传递调用关系。

示例异常信息（Stack Trace）：

Exception in thread "main" java.lang.NullPointerException
    at com.example.MyClass.myMethod(MyClass.java:10)
    at com.example.App.main(App.java:5)

4.2 Stack Trace 的结构组成

以典型的一条栈帧为例：

at com.example.MyClass.myMethod(MyClass.java:10)

部分	含义
at	表示当前调用栈的一帧
com.example.MyClass	异常发生的类
myMethod	异常发生的方法
(MyClass.java:10)	源码文件及第几行发生了异常（10 行）

4.3 堆栈追踪常见异常样式（举例对照）

1）NullPointerException（空指针）

Exception in thread "main" java.lang.NullPointerException
    at com.demo.DemoClass.printName(DemoClass.java:15)
    at com.demo.DemoClass.main(DemoClass.java:7)

分析：

• 异常发生在 DemoClass.java 的第 15 行

• 是从 main() 调用 printName() 时触发的

2）ClassCastException（类强制转换）

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at com.test.CastTest.main(CastTest.java:8)

分析：

• 明确告诉你：实际是 String，你试图转成 Integer

• 报错发生在第 8 行

4.4 如何进行堆栈追踪分析？

步骤 1：从上到下阅读栈帧（第一条才是出错点）

• 第一条是异常抛出的具体位置

• 后面的每条是“谁调用了它”

步骤 2：对照源码或反编译代码，定位具体代码行

• 使用 IDE 跳转对应行（Ctrl + 单击）

• 或用 jadx, JD-GUI, Fernflower 反编译查看 .class

步骤 3：结合异常类型，分析出错条件

• 是不是参数为 null？

• 是不是数据转换错误？

• 是不是调用了非法对象？

4.5 逆向调试场景中的应用

1）分析 App 崩溃日志

Caused by: java.lang.RuntimeException: 解密失败
	at com.app.secure.SecurityManager.decrypt(SecurityManager.java:87)
	at com.app.net.NetHandler.getUserInfo(NetHandler.java:122)

这说明：

• decrypt() 方法出错，可能在使用 AES、RSA 时 key 异常

• 你可以重点 hook 这一段代码，或者跟进加密过程逻辑

2）分析 Web 安全漏洞、异常行为

java.lang.IllegalArgumentException: 参数不合法
	at com.web.api.AuthHandler.checkToken(AuthHandler.java:52)
	at com.web.api.UserController.getUser(UserController.java:19)

说明：

• checkToken 方法校验失败，抛出异常

• 可用于判断接口是否有 token 依赖点，或可伪造点

3）结合 Frida 实现实时监控异常

可以使用 Frida 追踪所有异常抛出点：

Java.perform(function () {
    var Exception = Java.use("java.lang.Exception");
    Exception.$init.overload('java.lang.String').implementation = function (msg) {
        console.log("Exception 被抛出: " + msg);
        return this.$init(msg);
    };
});

4.6 分析：Caused by 和 Suppressed

Caused by

有时异常是嵌套异常，会看到：

Exception in thread "main" java.lang.Exception: 顶层异常
Caused by: java.io.IOException: 文件不存在
	at com.file.Reader.read(Reader.java:45)

• Caused by 表示底层真正触发的异常

• 要分析最底层原因

Suppressed

当使用 try-with-resources 时，可能出现：

Suppressed: java.lang.Exception: 关闭资源失败

说明主异常之后还有资源释放过程中的异常。

4.7 小结（堆栈分析三步法）

堆栈分析三步法：
1. 定位第 1 行出错代码（准确行号）
2. 判断异常类型及触发原因
3. 向上追踪调用链，分析调用过程

4.8 实战建议

场景	技巧
逆向异常分析	拿到 crash log，反编译对应类，查找触发条件
安全测试中断点排查	抓住抛异常的函数，设置 Frida Hook 或 JDWP 调试点
Web 渗透中判断逻辑	利用返回错误堆栈，看系统是怎么解析参数和验证身份