Java多异常类型捕获时如何保留原类型实现异常链传递？

我有一个会抛出多种自定义Exception类型的函数，希望捕获这些异常后添加重要信息，再以原异常类型向上传递（异常链），且尽可能用单个catch块实现。

我了解Java 7+支持多Exception类型捕获并保留原类型抛出，但进行异常链处理时，在同一个catch块中操作会丢失原类型。请问能否在单个捕获多异常类型的catch块中，抛出时保留原异常类型？还是必须拆分为3个近乎重复的catch块？

示例代码：

void thisWorks() {
    try {
        someFunction(); // 抛出ExceptionA, ExceptionB, ExceptionC
    } catch (ExceptionA | ExceptionB | ExceptionC exception) {
        throw exception; // 仍然保留原ExceptionA/ExceptionB/ExceptionC类型
    }
}
void whatIWant() {
    try {
        someFunction();
    } catch (ExceptionA | ExceptionB | ExceptionC exception) {
        // 这里抛出的是Exception，不是原ExceptionA/ExceptionB/ExceptionC类型
        // 能不能像thisWorks()那样用单个块实现？
        // 还是说必须拆成3个几乎重复的catch块才能保留抛出类型？
        throw new Exception("这里是重要信息", exception);
    }
}

方案1：统一自定义异常的构造方法（推荐） #

如果你的ExceptionA、ExceptionB、ExceptionC都是自定义异常，先让它们继承同一个父类，并统一实现带消息和异常原因的构造方法，这样就能在单个catch块里统一处理：

// 自定义异常父类
abstract class BaseCustomException extends Exception {
    public BaseCustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 各自定义异常继承父类并实现构造方法
class ExceptionA extends BaseCustomException {
    public ExceptionA(String message, Throwable cause) {
        super(message, cause);
    }
    // 其他必要的构造方法...
}

class ExceptionB extends BaseCustomException {
    public ExceptionB(String message, Throwable cause) {
        super(message, cause);
    }
}

class ExceptionC extends BaseCustomException {
    public ExceptionC(String message, Throwable cause) {
        super(message, cause);
    }
}

// 单个catch块实现需求
void whatIWant() throws BaseCustomException {
    try {
        someFunction();
    } catch (ExceptionA | ExceptionB | ExceptionC exception) {
        BaseCustomException newException;
        if (exception instanceof ExceptionA) {
            newException = new ExceptionA("这里是重要信息", exception);
        } else if (exception instanceof ExceptionB) {
            newException = new ExceptionB("这里是重要信息", exception);
        } else {
            newException = new ExceptionC("这里是重要信息", exception);
        }
        throw newException;
    }
}

这种方式仅需少量类型判断，比拆分catch块更简洁，同时保证类型安全。

方案2：反射动态创建原类型异常（不推荐） #

如果无法修改自定义异常的代码，或者异常数量较多，可以用反射动态生成原类型的异常实例，传递新增消息和原异常作为原因：

import java.lang.reflect.Constructor;

void whatIWant() throws ExceptionA, ExceptionB, ExceptionC {
    try {
        someFunction();
    } catch (ExceptionA | ExceptionB | ExceptionC exception) {
        try {
            // 获取原异常类中带String和Throwable参数的构造方法
            Constructor<? extends Exception> constructor = exception.getClass()
                .getConstructor(String.class, Throwable.class);
            // 创建新实例并抛出
            throw constructor.newInstance("这里是重要信息", exception);
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            // 反射失败时，直接抛出原异常兜底
            throw exception;
        }
    }
}

该方法灵活性高，但反射会带来性能损耗，代码可读性也较差，仅在迫不得已时使用。

方案3：拆分catch块（最直接） #

如果上述两种方案都不适用，拆分catch块是最直观的选择——虽然代码有重复，但逻辑清晰，类型明确：

void whatIWant() throws ExceptionA, ExceptionB, ExceptionC {
    try {
        someFunction();
    } catch (ExceptionA e) {
        throw new ExceptionA("这里是重要信息", e);
    } catch (ExceptionB e) {
        throw new ExceptionB("这里是重要信息", e);
    } catch (ExceptionC e) {
        throw new ExceptionC("这里是重要信息", e);
    }
}

后续修改消息或处理逻辑时，维护成本也较低。

关键结论 #

Java多异常catch块中，exception变量的编译类型是多个异常的公共父类（此处为Exception），无法直接自动推断原类型并创建新实例。要保留原类型抛出，必须通过类型判断+统一构造方法、反射或拆分catch块实现。

优先推荐方案1，兼顾简洁性与类型安全；无法修改异常类时，再考虑方案2或3。

内容的提问来源于stack exchange，提问作者StillLearning