设计模式的依赖倒转原则

传统的设计模式自顶向下逐级依赖 这样的话每一层的耦合度极高 修改任意的其中一个都会导致全面及的修改

#include <iostream>
using namespace std;
 
//依赖倒转原则
 
//上层模块
class BankWorker {
public:
    void saveService() {
        cout << "办理存款业务..." << endl;
    }
    void payService() {
        cout << "办理支付业务..." << endl;
    }
    void transferService() {
        cout << "办理转账业务" << endl;
    }
};
 
//中层模块
void doSaveBusiness(BankWorker* worker) {
    worker->saveService();
}
void doPayBusiness(BankWorker* worker) {
    worker->payService();
}
void doTransferBusiness(BankWorker* worker) {
    worker->transferService();
}
 
//底层模块
void test01() {
    BankWorker* worker = new BankWorker;
    doSaveBusiness(worker);//办理存款业务
    doPayBusiness(worker);//办理支付业务
    doTransferBusiness(worker);//办理转账业务
 
}
 
 
int main() {
    test01();
    return 0;
}

这里我们发现使用传统设计模式下 底层依赖于中层 中层依赖于上层 耦合性太强

这里我们可以改变一下 高层业务逻辑是依赖于抽象层 而具体的实现也是依赖于抽象层

#include <iostream>
using namespace std;
 
//依赖倒转原则
 
//银行工作人员 抽象层
class AbstractWorker {
public:
    virtual void doBusiness() = 0;
};
 
//专门负责办理存款业务的工作人员
class SaveBankWorker : public AbstractWorker {
public:
    virtual void doBusiness() {
        cout << "办理存款业务..." << endl;
    }
};
 
//专门办理支付业务的工作人员
class PayBankWorker : public AbstractWorker {
public:
    virtual void doBusiness() {
        cout << "办理支付业务..." << endl;
    }
};
 
//专门办理转账业务的工作人员
class TransferBankWorker : public AbstractWorker {
public:
    virtual void doBusiness() {
        cout << "办理转账业务..." << endl;
    }
};
 
//中层业务模块 依赖于抽象层 比业务更高一个层次了
//一个抽象类指针对象可以访问所有业务
void doNewBusiness(AbstractWorker* worker) {
    worker->doBusiness();
    delete worker;
}
 
//具体的实现层也是依赖于抽象层
void test02() {
 
    //（）里new出来的对象都用同一个抽象类指针去接收
    doNewBusiness(new TransferBankWorker);
    doNewBusiness(new PayBankWorker);
    doNewBusiness(new SaveBankWorker);
}
 
int main() {
    test02();
    //输出：办理转账业务...
    //      办理支付业务...
    //      办理存款业务...
 
    return 0;
}

总结：这里的精髓其实就是中层是使用抽象类作为一个接口 还是使用非抽象类去访问 因为抽象类作为接口可以访问所有子类对象 所以中层业务和具体实现层都可以依赖于抽象类对象