多方法基接口下仅实现少量方法的子类：合适设计模式咨询

针对你描述的大接口被子类部分实现、其余方法返回null的问题，核心是违反了接口隔离原则（ISP）——客户端不应依赖自身不需要的接口。以下是几种直接有效的重构方案：

1. 拆分单一职责的小接口 #

将原有的DealService大接口拆分为多个专注单一功能的小接口，每个接口仅包含一个核心方法：

interface DealDataProvider {
    DealData getDealData();
}

interface DealRestrictionsProvider {
    DealRestrictions getDealRestrictions();
}

interface DealRegisterProvider {
    DealRegister getDealRegister();
}

子类可按需实现对应接口：

• 仅处理交易数据的类，只需实现DealDataProvider
• 需要同时处理数据和限制的类，实现DealDataProvider + DealRestrictionsProvider

若需统一存储到列表中，可创建一个标记接口（如DealComponent）作为父接口，确保类型统一的同时，避免不必要的耦合。

2. 使用组合模式替代继承 #

放弃子类继承的方式，将每个功能封装为独立可复用的组件，通过组合组装所需功能：

// 定义独立功能组件
class DealDataComponent {
    DealData getDealData() {
        // 业务实现逻辑
    }
}

class DealRestrictionsComponent {
    DealRestrictions getDealRestrictions() {
        // 业务实现逻辑
    }
}

// 组合类，按需持有组件
class DealProcessor {
    private DealDataComponent dataComponent;
    private DealRestrictionsComponent restrictionsComponent;

    // 构造方法按需传入所需组件
    public DealProcessor(DealDataComponent dataComponent) {
        this.dataComponent = dataComponent;
    }

    public DealProcessor(DealDataComponent dataComponent, DealRestrictionsComponent restrictionsComponent) {
        this.dataComponent = dataComponent;
        this.restrictionsComponent = restrictionsComponent;
    }

    // 对外暴露方法，组件存在则调用，否则返回null（或按业务抛出异常）
    public DealData getDealData() {
        return dataComponent != null ? dataComponent.getDealData() : null;
    }

    public DealRestrictions getDealRestrictions() {
        return restrictionsComponent != null ? restrictionsComponent.getDealRestrictions() : null;
    }
}

这种方式让功能组件独立复用，组合类可灵活组装所需能力，避免了继承带来的冗余实现与耦合。

3. 过渡方案：抽象类提供默认实现 #

若暂时无法大规模拆分接口，可用抽象类替代接口，为所有方法提供默认返回null的实现，子类仅重写需要的方法：

abstract class AbstractDealService {
    public DealData getDealData() {
        return null;
    }

    public DealRestrictions getDealRestrictions() {
        return null;
    }

    public DealRegister getDealRegister() {
        return null;
    }
}

// 子类只需重写目标方法
class DealDataService extends AbstractDealService {
    @Override
    public DealData getDealData() {
        // 业务实现逻辑
    }
}

这是临时过渡方案，长期来看拆分接口更符合设计原则，可避免抽象类带来的继承耦合问题。

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