如何改进接口间面向对象设计并消除错误类的if-else分支

核心思路是用多态让具体错误类自己负责对应的状态处理逻辑，同时结合泛型统一事件处理流程，彻底干掉if-else分支和重复代码。

步骤1：提取Event通用接口 #

先给Event1和Event2定义公共接口，统一状态设置方法：

public interface Event {
    void setStatus(String status);
    // 其他通用方法也可以在此扩展
}

// 让原有事件类实现该接口
public class Event1 implements Event {
    // 原有代码保留
    @Override
    public void setStatus(String status) {
        // 原有setStatus逻辑
    }
}

public class Event2 implements Event {
    // 原有代码保留
    @Override
    public void setStatus(String status) {
        // 原有setStatus逻辑
    }
}

步骤2：改造Error类，用多态处理状态 #

修改Error抽象类，添加抽象处理方法，让每个具体错误子类实现自己的状态设置逻辑：

abstract class Error {
    // 抽象方法：让错误实例自己处理对应事件的状态
    public abstract void handleEventStatus(Event event);

    class NoProcessorFoundError extends Error {
        @Override
        public void handleEventStatus(Event event) {
            // 按事件类型设置对应状态，若想彻底消除这里的instanceof，可给Event加状态获取方法
            if (event instanceof Event1) {
                event.setStatus("RETRYABLE");
            } else if (event instanceof Event2) {
                event.setStatus("REJECTED");
            }
            // 原有...的逻辑直接移到这里
        }
    }

    class UnknownError extends Error {
        @Override
        public void handleEventStatus(Event event) {
            event.setStatus("FAILED");
            // 原有...的逻辑直接移到这里
        }
    }
}

如果想进一步优化，可给Event接口加getNoProcessorFoundStatus()方法，让每个事件子类返回自己对应的重试/驳回状态，这样NoProcessorFoundError里直接调用event.getNoProcessorFoundStatus()就能彻底消除分支。

步骤3：统一process方法，消除重复逻辑 #

用泛型+处理器参数，把process1和process2合并成通用方法：

private <T extends Event> Error process(T event, Consumer<T> processor) {
    processor.accept(event);
    // 原有process1/process2的公共逻辑
    if (true) { // 替换成实际判断条件
        return new Error.NoProcessorFoundError();
    } else {
        return new Error.UnknownError();
    }
}

步骤4：简化onEvent方法，彻底去掉if-else #

现在两个事件处理方法可以简化成：

public void onEvent1(Event1 event1) {
    Error result = process(event1, Event1processors::process);
    result.handleEventStatus(event1);
}

public void onEvent2(Event2 event2) {
    Error result = process(event2, Event2processors::process);
    result.handleEventStatus(event2);
}

甚至可以直接写一个通用的事件处理方法：

public <T extends Event> void onEvent(T event, Consumer<T> processor) {
    Error result = process(event, processor);
    result.handleEventStatus(event);
}

调用时直接传事件和对应处理器：onEvent(event1, Event1processors::process)、onEvent(event2, Event2processors::process)。

改造完成后，原来针对错误类型的if-else分支完全消失，新增错误类型时只需扩展Error子类并实现handleEventStatus方法即可，符合开闭原则。

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