如何高效处理实现Operand接口的多类对象组合逻辑？

针对你当前用嵌套switch处理不同Operand子类组合的问题，这里有几种更高效的方案，能大幅降低后续新增子类时的维护和测试成本：

1. 双分派模式（Double Dispatch） #

这是处理多态对象交互的经典方案，利用Java方法重载自动分发逻辑，无需手动判断identity值：

首先修改Operand接口，新增交互与类型处理方法：

public interface Operand {
    int getIdentity();
    
    // 让当前对象与另一个Operand完成交互
    void operateWith(Operand right);
    
    // 为每个子类类型定义专属处理方法
    void handleReal(Real real);
    void handleImaginary(Imaginary imaginary);
    void handleComplex(Complex complex);
}

然后每个子类实现这些方法，以Real类为例：

public class Real implements Operand {
    @Override
    public int getIdentity() {
        return 1;
    }

    @Override
    public void operateWith(Operand right) {
        // 调用右侧对象的对应处理方法，完成双分派
        right.handleReal(this);
    }

    @Override
    public void handleReal(Real real) {
        // 处理Real与Real的组合逻辑
    }

    @Override
    public void handleImaginary(Imaginary imaginary) {
        // 处理Real与Imaginary的组合逻辑
    }

    @Override
    public void handleComplex(Complex complex) {
        // 处理Real与Complex的组合逻辑
    }
}

Imaginary、Complex类同理，各自实现所有handleXXX方法。原function方法可简化为：

public void function(Operand left, Operand right) {
    left.operateWith(right);
}

优点：逻辑分散到对应子类，新增Operand子类时，编译器会强制检查未实现的handle方法，避免遗漏；符合OOP封装思想。
缺点：子类数量较多时，每个子类需要实现多个handle方法，代码量会增加，但比嵌套switch更易维护。

2. 策略模式+映射表 #

把每种组合的处理逻辑封装为独立策略类，用映射表统一管理组合与策略的对应关系：

首先定义处理逻辑接口：

public interface OperationHandler {
    void handle(Operand left, Operand right);
}

为每种组合实现专属策略，比如RealRealHandler：

public class RealRealHandler implements OperationHandler {
    @Override
    public void handle(Operand left, Operand right) {
        // 处理Real与Real的组合逻辑
    }
}

在function所在类中初始化映射表（可用Pair或自定义key）：

private static final Map<Pair<Integer, Integer>, OperationHandler> HANDLER_MAP = new HashMap<>();

static {
    // 初始化所有组合的策略映射
    HANDLER_MAP.put(new Pair<>(1, 1), new RealRealHandler());
    HANDLER_MAP.put(new Pair<>(1, 2), new RealImaginaryHandler());
    HANDLER_MAP.put(new Pair<>(1, 3), new RealComplexHandler());
    HANDLER_MAP.put(new Pair<>(2, 1), new ImaginaryRealHandler());
    // 其他组合依次添加
}

原function方法简化为：

public void function(Operand left, Operand right) {
    Pair<Integer, Integer> key = new Pair<>(left.getIdentity(), right.getIdentity());
    OperationHandler handler = HANDLER_MAP.get(key);
    if (handler == null) {
        throw new IllegalArgumentException("不支持的操作数组合");
    }
    handler.handle(left, right);
}

优点：处理逻辑集中管理，新增组合或子类时，只需添加新策略类和映射项，无需修改原有代码，符合开闭原则。
缺点：需额外创建多个策略类；若identity值变更，需同步修改映射表key。

3. Java 17+ 模式匹配Switch（简化版） #

如果项目使用Java 17及以上版本，可利用模式匹配switch替代基于identity的判断，代码更直观且编译器会检查未覆盖分支：

public void function(Operand left, Operand right) {
    switch (left) {
        case Real rLeft -> switch (right) {
            case Real rRight -> { /* Real-Real 逻辑 */ }
            case Imaginary iRight -> { /* Real-Imaginary 逻辑 */ }
            case Complex cRight -> { /* Real-Complex 逻辑 */ }
            default -> throw new IllegalArgumentException("不支持的右侧操作数");
        }
        case Imaginary iLeft -> switch (right) {
            case Real rRight -> { /* Imaginary-Real 逻辑 */ }
            case Imaginary iRight -> { /* Imaginary-Imaginary 逻辑 */ }
            case Complex cRight -> { /* Imaginary-Complex 逻辑 */ }
            default -> throw new IllegalArgumentException("不支持的右侧操作数");
        }
        case Complex cLeft -> switch (right) {
            case Real rRight -> { /* Complex-Real 逻辑 */ }
            case Imaginary iRight -> { /* Complex-Imaginary 逻辑 */ }
            case Complex cRight -> { /* Complex-Complex 逻辑 */ }
            default -> throw new IllegalArgumentException("不支持的右侧操作数");
        }
        default -> throw new IllegalArgumentException("不支持的左侧操作数");
    }
}

优点：无需依赖getIdentity()方法，直接基于类型判断，可读性更高；编译器会提示未覆盖的类型分支，避免遗漏。
缺点：仍存在嵌套结构，新增子类时需添加对应的case分支，但比基于identity的switch更安全（编译期类型检查）。

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