【华为鸿蒙开发技术】仓颉语言异常处理详解：自定义、抛出与捕获机制

在现代软件开发中，异常处理是保障程序健壮性和正确性的重要手段。仓颉语言提供了独特的异常处理机制，允许开发者通过捕获和处理运行时的异常，提升系统的稳定性。本文将详细介绍仓颉语言中的异常类型、抛出和捕获异常的方式以及资源管理相关的高级特性。

1. 异常的基本定义

异常（Exception）指的是程序执行过程中发生的非正常行为，如数组越界、除零错误、文件不存在等。异常不属于程序的正常功能，当异常发生时，程序需要立即处理这些异常，从正常流程转移至异常处理流程。

仓颉语言将异常划分为两类：

• Error: 系统内部错误或资源耗尽错误。应用程序不应该抛出此类错误，它们主要用于通知用户系统已经遇到无法恢复的错误，程序应当安全终止。
• Exception: 由逻辑错误或I/O错误引起的异常，如数组越界、文件不存在等。开发者可以捕获并处理这些异常，确保程序能够在错误发生后继续执行或以预期方式处理。

2. 自定义异常

仓颉语言允许开发者通过继承内置的 Exception 类或其子类来创建自定义异常。以下是一个示例：

open class FatherException <: Exception {
    public open func printException() {
        print("I am a FatherException")
    }
}

class ChildException <: FatherException {
    public override func printException() {
        print("I am a ChildException")
    }
}

在此示例中，FatherException 和 ChildException 都是基于 Exception 类的自定义异常。这种机制允许开发者根据具体业务场景定制异常类型，并在捕获异常时进行更加精细的异常处理。

3. 抛出异常

抛出异常使用关键字 throw。通过 throw，开发者可以主动引发程序中的异常。需要注意的是，throw 后面的表达式必须是 Exception 的子类。例如：

throw ArithmeticException("I am an Exception!")

当代码执行到这行时，程序会抛出一个算术运算异常。需要捕获并处理这个异常，否则系统会调用默认的异常处理器。

4. 捕获和处理异常

异常处理通过 try-catch-finally 语句实现。try 块中包含可能抛出异常的代码，而 catch 块用于捕获和处理这些异常。finally 块中的代码则无论异常是否发生都会执行，通常用于释放资源。

示例：普通异常处理

main() {
    try {
        throw NegativeArraySizeException("I am an Exception!")
    } catch (e: NegativeArraySizeException) {
        println(e)
        println("NegativeArraySizeException is caught!")
    }
    println("This will also be printed!")
}

执行结果：

NegativeArraySizeException: I am an Exception!
NegativeArraySizeException is caught!
This will also be printed!

在这个例子中，异常被成功捕获并处理，程序继续执行其他代码。

示例：带有 finally 块的异常处理

main() {
    try {
        throw NegativeArraySizeException("NegativeArraySizeException")
    } catch (e: NegativeArraySizeException) {
        println("Exception info: ${e}.")
    } finally {
        println("The finally block is executed.")
    }
}

执行结果：

Exception info: NegativeArraySizeException: NegativeArraySizeException.
The finally block is executed.

无论是否发生异常，finally 块中的代码都会执行，这为资源释放和清理工作提供了保障。

5. 资源管理中的 try-with-resources

仓颉语言还提供了 try-with-resources 语法，用于自动管理资源的释放。当在 try-with-resources 中申请资源时，无论是否发生异常，资源都会自动释放。以下是一个简单的示例：

class R <: Resource {
    public func isClosed(): Bool {
        true
    }
    public func close(): Unit {
        print("R is closed")
    }
}

main() {
    try (r = R()) {
        println("Get the resource")
    }
}

执行结果：

Get the resource
R is closed

在此例中，即使 try 块中发生异常，资源 R 也会自动关闭，而不需要手动释放。这种机制对于需要管理外部资源（如文件、网络连接等）的程序非常有用。

6. CatchPattern 高级用法

当需要捕获多种类型的异常时，仓颉语言提供了 CatchPattern 的类型模式和通配符模式。类型模式可以匹配特定类型及其子类的异常，而通配符模式则可以捕获所有异常类型，常用于统一处理异常的场景。

示例：类型模式

main() {
    try {
        throw NegativeArraySizeException("Negative Array Size")
    } catch (e: NegativeArraySizeException | ArithmeticException) {
        println("Caught an exception!")
    }
}

这里的 catch 块同时捕获 NegativeArraySizeException 和 ArithmeticException 两种异常类型。

7. 匹配多个异常类型

仓颉语言支持在一个 catch 块中捕获多个异常类型。开发者可以使用 | 运算符来同时捕获多种类型的异常。这种语法在处理相似类型的异常时非常高效。

示例：捕获多个异常类型

main() {
    try {
        // 模拟一个异常
        throw ArithmeticException("Division by zero!")
    } catch (e: ArithmeticException | NegativeArraySizeException) {
        println("Caught an arithmetic or negative array size exception!")
    }
}

在这个例子中，无论是 ArithmeticException 还是 NegativeArraySizeException，都会被相同的 catch 块捕获并处理。这样可以避免重复编写相似的异常处理代码。

8. 自定义异常消息和嵌套异常

在仓颉语言中，异常类允许开发者传递自定义的错误消息，这使得调试变得更加方便。此外，仓颉还支持嵌套异常（Nested Exception），即一个异常可以包含另一个异常，通常用于传递更详细的错误信息。

示例：自定义异常消息

main() {
    try {
        throw ArithmeticException("Custom error message: Division by zero!")
    } catch (e: ArithmeticException) {
        println(e.getMessage())
    }
}

输出结果：

Custom error message: Division by zero!

在这个示例中，getMessage() 方法用于获取异常对象的详细错误信息。

示例：嵌套异常

class CustomException <: Exception {
    public func init(message: Str, cause: Exception) {
        super.init(message, cause)
    }
}

main() {
    try {
        try {
            throw ArithmeticException("Cause of error")
        } catch (e: ArithmeticException) {
            throw CustomException("Custom exception with cause", e)
        }
    } catch (e: CustomException) {
        println("Caught custom exception: ${e.getMessage()}")
        println("Original cause: ${e.getCause().getMessage()}")
    }
}

输出结果：

Caught custom exception: Custom exception with cause
Original cause: Cause of error

在此例中，CustomException 包含了 ArithmeticException 作为它的 “cause”（原因）。通过嵌套异常，开发者可以在抛出新的异常时，保留原始异常信息，帮助更好地跟踪问题的根源。

9. 重新抛出异常

在某些情况下，捕获异常后需要再次抛出，通常是为了将异常传递给更高层的调用者。在仓颉语言中，可以通过简单地使用 throw 语句来重新抛出异常。

示例：重新抛出异常

main() {
    try {
        handleException()
    } catch (e: Exception) {
        println("Exception caught in main: ${e.getMessage()}")
    }
}

func handleException() {
    try {
        throw ArithmeticException("Arithmetic error")
    } catch (e: ArithmeticException) {
        println("Caught in handleException: ${e.getMessage()}")
        throw e // 重新抛出异常
    }
}

输出结果：

Caught in handleException: Arithmetic error
Exception caught in main: Arithmetic error

在这个示例中，handleException() 捕获了异常，但在处理后将异常重新抛出，最终在 main() 函数中再次捕获。

10. 异常链（Chained Exceptions）

仓颉支持异常链，允许一个异常关联到另一个异常，形成异常的因果链。这种特性对于记录问题的追踪信息非常有帮助。通过异常链，开发者可以清楚地知道某个错误是如何逐步引发其他错误的。

示例：使用异常链

class FirstException <: Exception {}
class SecondException <: Exception {}

main() {
    try {
        try {
            throw FirstException("First exception")
        } catch (e: FirstException) {
            throw SecondException("Second exception", e)
        }
    } catch (e: SecondException) {
        println("Caught second exception: ${e.getMessage()}")
        println("Caused by: ${e.getCause().getMessage()}")
    }
}

输出结果：

Caught second exception: Second exception
Caused by: First exception

在这个例子中，SecondException 被 FirstException 所引发，并通过 getCause() 方法可以追溯异常链中的原始异常信息。

11. 未捕获异常处理器

在一些大型应用中，开发者可能希望为整个应用设置一个统一的异常处理策略，用于捕获未被处理的异常。仓颉提供了 UncaughtExceptionHandler 来处理这种情况。

示例：全局异常处理器

class GlobalExceptionHandler <: UncaughtExceptionHandler {
    public override func handle(exception: Exception) {
        println("Unhandled exception caught: ${exception.getMessage()}")
    }
}

main() {
    setUncaughtExceptionHandler(GlobalExceptionHandler())
    throw ArithmeticException("Unhandled division by zero")
}

在此示例中，程序为未捕获的异常设置了一个全局的异常处理器。当出现未捕获的 ArithmeticException 时，它将由 GlobalExceptionHandler 处理。

12. 异常的层次化处理

在复杂的应用中，开发者可以根据异常的层次结构进行不同级别的处理。例如，某些异常可以在较低级别捕获和处理，而较为严重的异常可以传递到更高级别进行进一步处理。

示例：异常的层次化处理

main() {
    try {
        level1()
    } catch (e: Exception) {
        println("Caught in main: ${e.getMessage()}")
    }
}

func level1() {
    try {
        level2()
    } catch (e: ArithmeticException) {
        println("Handled ArithmeticException in level1")
        throw e // 继续抛出给上一级
    }
}

func level2() {
    throw ArithmeticException("Division by zero")
}

输出结果：

Handled ArithmeticException in level1
Caught in main: Division by zero

在这个例子中，level1() 捕获了异常并进行了部分处理，但最终将异常重新抛出，传递给 main() 函数进行最终处理。

13. 异常的最佳实践

• 适当捕获: 仅在有必要的地方捕获异常，不要滥用异常捕获。
• 提供有意义的错误信息: 自定义异常或抛出异常时，确保提供有用的错误信息，便于调试和日志记录。
• 使用异常链: 当需要传递多层次的异常信息时，使用异常链来保留原始异常的细节。