Java异常处理和链式异常实例

原创叁歲伎倆 2024-09-10 20:03 82阅读 0赞

在Java编程中，异常处理是一个重要的概念，用于处理程序运行过程中可能出现的错误情况。链式异常则是Java 7引入的一种新的异常结构。

下面是一个使用Java异常处理和链式异常的简单例子：

```java
public class ExceptionHandlingExample {

public static void main(String[] args) {
        try {
            // 链式异常示例：抛出一个错误，然后从错误中获取另一个错误
            String str = readFromSomewhere();
            System.out.println("The string is: " + str);

// 这里可能会抛出一个自定义异常
            performSomeComplexOperation(str);
        } catch (NumberFormatException e) { // 处理数字格式错误的异常
            System.out.println("Error parsing number: " + e.getMessage());
        } catch (CustomException ex) { // 处理自定义异常
            System.out.println("Error in custom operation: " + ex.getMessage());
            // 从错误中获取另一个错误
            handleSecondException(ex.getAnotherException()));
        }
    }

// 假设这是一个读取数据的函数，可能会抛出NumberFormatException
    private static String readFromSomewhere() throws NumberFormatException {
        int someValue = 0; // 这里只是一个模拟
        if (someValue < 0) {
            throw new NumberFormatException("Negative value detected");
        }
        return String.valueOf(someValue);
    }

// 假设这是一个执行复杂操作的函数，可能会抛出CustomException
    private static void performSomeComplexOperation(String str) throws CustomException {
        int anotherValue = 0; // 这里只是一个模拟
        if (anotherValue < 0) {
            throw new CustomException("Negative value detected in complex operation");
        }
        
        // 假设这里是一个对复杂操作敏感的业务逻辑
        if (str.contains("error")) {
            throw new CustomException("Error encountered during complex operation");
        }

// 这里可能会抛出另一个自定义异常
        try {
            performSubOperation(anotherValue);
        } catch (CustomException ex) {
            throw new CustomException("Error in sub operation", ex.getAnotherException()));
        }
    }

private static void handleSecondException(CustomException secondEx) throws CustomException {
        System.out.println("Handling second exception: " + secondEx.getMessage());

// 这里假设需要处理的异常是特定范围内的错误
        if (secondEx.getCode() >= 500 && secondEx.getCode() < 600) {
            throw new CustomException("Error handling the second exception", secondEx.getAnotherException()));
        } else {
            System.out.println("No action required for the second exception.");
        }
    }

// 假设这是一个子操作，可能会抛出自定义异常
    private static void performSubOperation(int value) throws CustomException {
        if (value < 0) {
            throw new CustomException("Negative value detected in sub operation", null);
        }

// 这里假设需要处理的特定范围内的错误代码是100
        if (value == 100) {
            throw new CustomException("Error encountered in sub operation with code 100", null);
        }
        
        System.out.println("Performing sub operation: " + value);

// 这里假设需要对子操作进行一些验证，如果不符合要求则抛出异常
        if (value % 2 != 0) {
            throw new CustomException("Invalid value detected in sub operation. Value should be even.", null);
        }
    }
}
```

在这个例子中，我们首先定义了一个可能会抛出NumberFormatException的函数readFromSomewhere()。然后在另一个可能会抛出CustomException的函数performSomeComplexOperation()中，我们调用了这个子操作。

最后，我们在main方法中使用try-catch结构来处理可能的异常。通过链式异常的方式，我们可以从一个错误中获取另一个错误的信息，并进行相应的处理。