设计模式04-依赖倒转原则

---

传统的面向过程的程序设计使高层次的模块自顶向下逐级依赖于低层次的模块，中间层和高层模块之间存在较高的耦合度，这样如果其中一个模块发生变化，整个业务就会受影响。

例如下面的例子

#include <iostream>
using namespace std;

// 高层
class BankWorker {
public:
	void saveService() {
		cout << "save service\n";
	}
	void payService() {
		cout << "pay service\n";
	}
	void transferService() {
		cout << "transfer service\n";
	}
};

// 中间层模块1-依赖于银行员工
void do_savebussiness(BankWorker* bw) {
	bw->saveService();
}

// 中间层模块2-依赖于银行员工
void do_paybussiness(BankWorker* bw) {
	bw->payService();
}

// 中间层模块3-依赖于银行员工
void do_transferbussiness(BankWorker* bw) {
	bw->transferService();
}

// 底层依赖于中间层
void test() {
	BankWorker* pworker = new BankWorker;
	do_savebussiness(pworker);
	do_paybussiness(pworker);
	do_transferbussiness(pworker);
	delete pworker;
}

int main() {

	test();
	return 0;
}

现在，应当使高层模块只依赖于中间的抽象层，底层的实现也只依赖于中间的抽象层，达到底层和上层解耦的目的

#include <iostream>
using namespace std;

class AbstractWorker {
public:
	virtual void doBussiness() = 0;
};

class payWorker : public AbstractWorker {
	void doBussiness() {
		cout << "pay service\n";
	}
};

class saveWorker : public AbstractWorker {
	void doBussiness() {
		cout << "save service\n";
	}
};

// 中层模块
void doBusnes(AbstractWorker* pw) {
	pw->doBussiness();
	delete pw;
}

void test() {
	doBusnes(new payWorker);
	doBusnes(new saveWorker);
}

int main() {

	test();
	return 0;
}

这样，当银行添加新业务的时候，只要派生出新的员工即可，不会影响底层模块的函数调用