[架构设计] 设计原则

目录

一、目的--设计原则解决的问题

二、设计原则

2.1 原则概念

2.2 开闭原则

2.3 迪米特法则

2.4 合成复用原则

2.5 依赖倒置原则

---

一、目的--设计原则解决的问题

支持可维护性的同时，提高系统的可复用性，达到高内聚，低耦合目的。

二、设计原则

2.1 原则概念

2.2 开闭原则

#include 
using namespace std;
 
//写一个抽象类 ,方便扩展其他操作，而不是直接采用一个类，每次都要修改类的源码
class AbstractCaculator {
public:
	virtual int getResult() = 0;
	virtual void setOperatorNumber(int a, int b) = 0;
};
 
//加法计算器
class PlusCalcultor :public AbstractCaculator {
public:
	virtual void setOperatorNumber(int a,int b) {
		this->mA = a;
		this->mB = b;
	}
	virtual int getResult() {
		return mA + mB;
	}
private:
	int mA;
	int mB;
};
 
//减法计算器类
class MinuteCalcultor :public AbstractCaculator {
public:
	virtual void setOperatorNumber(int a, int b) {
		this->mA = a;
		this->mB = b;
	}
	virtual int getResult() {
		return mA - mB;
	}
private:
	int mA;
	int mB;
};
 
//乘法计算器类
class MultiplyCalcultor :public AbstractCaculator {
public:
	virtual void setOperatorNumber(int a, int b) {
		this->mA = a;
		this->mB = b;
	}
	virtual int getResult() {
		return mA * mB;
	}
private:
	int mA;
	int mB;
};
 
 
int main(void)
{
	AbstractCaculator* calcultor = new PlusCalcultor;
	calcultor->setOperatorNumber(10,20);
	cout<getResult()<
 
	delete calcultor; 
 
	calcultor = new MinuteCalcultor;
	calcultor->setOperatorNumber(10, 20);
	cout << calcultor->getResult() << endl;
 
	delete calcultor;
	calcultor = NULL;   
 
    return 0;
}

2.3 迪米特法则

#include 
#include 
#include 
using namespace std;
 
//迪米特原则，又叫最少知道原则，
class AbstractBuilding {
public:
	virtual void sale() = 0;
	virtual string getQuality() = 0;
};
 
//楼盘A
class BuildingA :public AbstractBuilding {
public:
	BuildingA() { mQuilty = "高品质"; };
	virtual void sale() {
		cout << "楼盘A" << mQuilty<<"被售卖！"<
	}
	virtual string getQuality() {
		return mQuilty;
	}
private:
	string mQuilty;
};
 
//楼盘B
class BuildingB :public AbstractBuilding {
public:
	BuildingB() { mQuilty = "低品质"; };
	virtual void sale() {
		cout << "楼盘B" << mQuilty << "被售卖！" << endl;
	}
	virtual string getQuality() {
		return mQuilty;
	}
private:
	string mQuilty;
};
 
 
//引入中介类，可以方便直接找到对应品质，而无需暴露所有楼盘
// 因此需要在中介类中汇总所有信息，方便查找
class Mediator {
public:
	Mediator() {
		AbstractBuilding* building = new BuildingA;
		vBuilding.push_back(building);
		building = new BuildingB;
		vBuilding.push_back(building);
	};
 
	//对外提供接口
	AbstractBuilding* findMyBuilding(string quality) {
		for (auto it : vBuilding) {
			if ((it)->getQuality() == quality) {
				return it;
			}
		}
		return NULL;
	}
 
	~Mediator() {
		for (vector::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
			if (*it != NULL) {
				delete *it;
			}
		}
	}
public:
	vector vBuilding;
};
 
 
int main() {
	Mediator* mediator = new Mediator;
 
	AbstractBuilding* building = mediator->findMyBuilding("高品质");
 
	if (building != NULL) {
		building->sale();
	}
	else {
		cout << "没有符合您条件的楼盘！" << endl;
	}
	return 0;
}

2.4 合成复用原则

#include 
using namespace std;
 
//抽象车
class AbstractCar {
public:
	virtual void run() = 0;
 
};
 
//大众车
class Dazhong :public AbstractCar {
public:
	virtual void run() {
		cout << "大众车启动" << endl;
	}
};
 
//拖拉机
class Tuolaji :public AbstractCar {
public:
	virtual void run() {
		cout << "拖拉机启动" << endl;
	}
};
 
//针对具体类 不适用继承，作为成员，而不是直接继承
#if 0
class Person :public Tuolaji {
public:
	void Dongfeng() {
		run();
	}
};
class Person2 :public Dazhong {
public:
	void Dazhong() {
		run();
	}
};
#endif
 
//可以使用合成复用原则
class Person {
public:
	void setCar(AbstractCar* car) {
		this->car = car;
	}
	void Dongfeng() {
		this->car->run();
		if (this->car != NULL) {
			delete this->car;
			this->car = NULL;
		}
	}
 
public:
	AbstractCar* car;
};
 
 
//继承和组合优先使用组合
int main() {
	Person* p = new Person;
	p->setCar(new Dazhong);
	p->Dongfeng();
 
	p->setCar(new Tuolaji);
	p->Dongfeng();
 
	delete p;
	return 0;
}

2.5 依赖倒置原则

依赖不合理方式

#include 
using namespace std;;
 
 
//银行工作人员
class BankWorker {
public:
	void saveService() {
		cout << "办理存款业务..." << endl;
	}
	void payService() {
		cout << "办理支付业务..." << endl;
	}
	void tranferService() {
		cout << "办理转账业务..." << endl;
	}
 
};
 
//中层模块
void doSaveBussiness(BankWorker* worker) {
	worker->saveService();
}
 
void doPayBussiness(BankWorker* worker) {
	worker->payService();
}
 
void doTranferBussiness(BankWorker* worker) {
	worker->tranferService();
}
 
 
int main()
{
    BankWorker* worker = new BankWorker;
	doSaveBussiness(worker);  //办理存款业务
	doPayBussiness(worker); //办理支付业务
	doTranferBussiness(worker); //办理转账业务
	return 0;
}

依赖合理方式

#include 
using namespace std;;
 
//依赖倒转原则
//抽象层
class AbstractWorkerBank {
public:
	virtual void doBussiness() = 0;
};
 
//只办理存款业务
class SaveBankWorker : public  AbstractWorkerBank {
public:
	virtual void doBussiness() {
		cout << "办理存款业务" << endl;
	}
};
 
//只办理转账业务
class TransferBankWorker : public  AbstractWorkerBank {
public:
	virtual void doBussiness() {
		cout << "办理存款业务" << endl;
	}
};
 
//只办理付款业务
class PayBankWorker : public  AbstractWorkerBank {
public:
	virtual void doBussiness() {
		cout << "办理存款业务" << endl;
	}
};
 
//高层模块
void DoBankBussiness(AbstractWorkerBank* worker) {
	worker->doBussiness();
	delete worker;
}
 
 
int main()
{
	DoBankBussiness(new SaveBankWorker); //办理存款业务
	DoBankBussiness(new TransferBankWorker); //办理转账业务
	DoBankBussiness(new PayBankWorker); //办理付款业务
	return 0;
}
 

好在哪里？做了一层真正的抽象，完全只依赖接口，避免了依赖具体实现，从而能够保证隔层，保证上下层真正不会造成耦合影响。