Java中如何处理特定子类抛出的异常？求更优雅方案

你的核心问题是Java方法重写的异常规则导致的契约冲突：子类Train重写accelerate时抛出了父类Vehicle原本不会抛出的TrainSpeedChange检查型异常，为了符合重写规则（子类不能抛出比父类更宽泛的检查异常），你被迫在父类方法上声明这个异常，进而导致其他正常子类（Car、AirCraft）的调用者必须处理本不可能出现的异常，这明显违背了代码的语义合理性。

方案一：将TrainSpeedChange改为运行时异常（最简便） #

TrainSpeedChange的语义是“调用了不该调用的方法”，属于调用逻辑错误，而非程序运行时的可恢复异常，完全适合用运行时异常（RuntimeException）来表示。这样父类不需要声明该异常，子类重写时抛出也无需在方法签名中声明，彻底解决契约冲突。

修改代码： #

1. 调整异常类：

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

2. 父类Vehicle的accelerate方法移除TrainSpeedChange声明：

public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed {
    // 原有逻辑保持不变
    if(speed + amount > speedLimit)
        throw new ExceedSpeedLimit("Current speed is " + speed + ". Accelerate " + amount + " will exceed the speed limit!");
    if(speed + amount < 0)
        throw new NotEnoughSpeed("Current speed is " + speed + ", not enough speed to decelerate!");
    else {
        speed += amount;
        return speed;
    }
}

3. Train类的重写方法无需声明throws：

@Override
public int accelerate(int amount) {
    throw new TrainSpeedChange("Do not try to accelerate or decelerate the train!");
}

这样Car和AirCraft无需任何修改，调用它们的accelerate时只需要处理ExceedSpeedLimit和NotEnoughSpeed，完全符合语义。

方案二：重构类层次，拆分可变速契约（最严谨） #

如果希望严格区分“可变速交通工具”和“不可变速交通工具”的行为契约，可以通过接口拆分来实现：

修改代码： #

1. 基类Vehicle只保留通用属性和方法，不包含accelerate：

public abstract class Vehicle {
    private int speedLimit;
    private int speed;

    // 提供getter/setter，或者protected方法让子类访问
    protected int getSpeed() { return speed; }
    protected void setSpeed(int speed) { this.speed = speed; }
    protected int getSpeedLimit() { return speedLimit; }
    // 其他通用方法...
}

2. 创建Acceleratable接口定义可变速行为：

public interface Acceleratable {
    int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed;
}

3. Car和AirCraft实现该接口：

public class Car extends Vehicle implements Acceleratable {
    @Override
    public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed {
        int currentSpeed = getSpeed();
        int newSpeed = currentSpeed + amount;
        if(newSpeed > getSpeedLimit()) {
            throw new ExceedSpeedLimit("Current speed is " + currentSpeed + ". Accelerate " + amount + " will exceed the speed limit!");
        }
        if(newSpeed < 0) {
            throw new NotEnoughSpeed("Current speed is " + currentSpeed + ", not enough speed to decelerate!");
        }
        setSpeed(newSpeed);
        return newSpeed;
    }
}

4. Train类不实现Acceleratable，如果需要提示错误，可以单独定义方法：

public class Train extends Vehicle {
    public void attemptAccelerate(int amount) {
        throw new TrainSpeedChange("Do not try to accelerate or decelerate the train!");
    }
}

这种方案从根源上分离了不同类型交通工具的行为契约，调用者只能对Acceleratable类型的对象调用accelerate，完全避免了异常声明的冲突问题。

你通过子类重写窄化异常范围，再捕获父类方法中不可能抛出的TrainSpeedChange，本质是用代码逻辑“掩盖”了设计上的契约冲突，不仅冗余，还埋下了隐患——如果未来父类逻辑变化意外抛出该异常，你的catch块会直接吞掉错误，导致调试困难。

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