2.C++设计模式-面向对象原则

2.面向对象设计原则

2.1 开闭原则

开闭原则：类的改动是通过增加代码进行的，而不是修改源代码。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
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;
	}
public:
	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;
	}
public:
	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;
	}
public:
	int mA;
	int mB;
};

void test01() {
	AbstractCaculator* calcultor = new PlusCalcultor;
	calcultor->setOperatorNumber(10,20);
	cout<<calcultor->getResult()<<endl;

	delete calcultor;  //变成一个野指针

	calcultor = new MinuteCalcultor;
	calcultor->setOperatorNumber(10, 20);
	cout << calcultor->getResult() << endl;

	delete calcultor;
	calcultor = NULL;   //需要立刻置为NULL	
}

int main() {
	test01();
	return 0;
}

2.2 迪米特原则（最少知道原则）

==一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。==例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。（黑盒原理）

#include <iostream>
#include <string>
#include <vector>
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<<"被售卖！"<<endl;
	}
	virtual string getQuality() {
		return mQuilty;
	}
public:
	string mQuilty;
};

//楼盘B
class BuildingB :public AbstractBuilding {
public:
	BuildingB() { mQuilty = "低品质"; };
	virtual void sale() {
		cout << "楼盘B" << mQuilty << "被售卖！" << endl;
	}
	virtual string getQuality() {
		return mQuilty;
	}
public:
	string mQuilty;
};

//客户端
void test01() {
	BuildingA* ba = new BuildingA;
	if (ba->mQuilty == "低品质") {
		ba->sale();
	}

	BuildingB* bb = new BuildingB;
	if (bb->mQuilty == "低品质") {
		bb->sale();
	}
}

//中介类
class Mediator {
public:
	Mediator() {
		AbstractBuilding* building = new BuildingA;
		vBuilding.push_back(building);
		building = new BuildingB;
		vBuilding.push_back(building);
	};

	//对外提供接口
	AbstractBuilding* findMyBuilding(string quality) {
		//for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
		//	if ((*it)->getQuality() == quality){
		//		return *it;
		//	}
		//}
		for (auto it : vBuilding) {
			if ((it)->getQuality() == quality) {
				return it;
			}
		}
		return NULL;
	}

	~Mediator() {
		for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
			if (*it != NULL) {
				delete *it;
			}
		}
	}
public:
	vector<AbstractBuilding*> vBuilding;
};

void test02() {
	Mediator* mediator = new Mediator;

	AbstractBuilding* building = mediator->findMyBuilding("高品质");

	if (building != NULL) {
		building->sale();
	}
	else {
		cout << "没有符合您条件的楼盘！" << endl;
	}
}

int main() {
	test02();
	return 0;
}

2.3 合成复用原则

如果使用继承，会导致父类的任何变换都可能影响到子类的行为。
如果使用对象组合，就降低了这种依赖关系。对于继承和组合，优先使用组合。

#include <bits/stdc++.h>
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;
};

void test02() {
	Person* p = new Person;
	p->setCar(new Dazhong);
	p->Dongfeng();

	p->setCar(new Tuolaji);
	p->Dongfeng();

	delete p;
}


//继承和组合优先使用组合
int main() {
	test02();
	return 0;
}

2.4 依赖倒转原则

依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程。

2.4.1 传统

#include <bits/stdc++.h>
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();
}

void test01() {
	BankWorker* worker = new BankWorker;
	doSaveBussiness(worker);  //办理存款业务
	doPayBussiness(worker); //办理支付业务
	doTranferBussiness(worker); //办理转账业务
}

int main()
{
    test01();
	return 0;
}

2.4.2 依赖倒转原则

#include <bits/stdc++.h>
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;
}

void test02() {

	DoBankBussiness(new SaveBankWorker); //办理存款业务
	DoBankBussiness(new TransferBankWorker); //办理转账业务
	DoBankBussiness(new PayBankWorker); //办理付款业务

}


int main()
{
    test02();
	return 0;
}