设计模式（1）

开闭原则：

概念：开闭原则：对扩展开放，对修改关闭，增加功能是通过增加代码实现的，而不是去修改源代码

例如实现计算器的加减乘除：

需要建立的是以个抽象类，把实现方法放在子类里面进行重写。避免在修改中，出现错误，查找错误不方便。

原来代码：

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;
// 开闭原则 对扩展开放，对修改关闭，增加功能是通过增加代码来实现，而不是去修改源代码


//语算器类
class Caculaor{
private:
	int m_a;
	int m_b;
	string m_operator;
	int m_ret;
public:
	Caculaor(int a, int b, string moperator){
		this->m_a = a;
		this->m_b = b;
		this->m_operator = moperator;
	}


	int getResult(){
		if (m_operator.compare("+") == 0){
			return m_a + m_b;
		}
		else if (m_operator.compare("-") == 0){
			return m_a - m_b;
		}
		else if (m_operator.compare("*") == 0){
			return m_a*m_b;
		}
		else if (m_operator.compare("/") == 0) {
			return m_a / m_b;
		}
	}

};
/*
缺点：如果增加取模的运算需要修改getResult成员方法，如果增加新功能的情况下要修改调代码，那么
就会有修改出错的可能性。
我们应该在增加新的功能时候，不能影响其他已经完成的功能。
这就是对修改关闭，对扩展开放，叫做开闭原则
*/


void test01(){
	Caculaor* caculator = new Caculaor(10, 20, "+");
	cout << caculator->getResult() << endl;
}


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

修改之后： 

#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 PlusCaculator :public AbstractCaculator{
		public:
			int mA;
			int mB;
		
		public:
			virtual void setOperatorNumber(int a, int b){
				   this->mA = a; 
				   this->mB = b; 
			}

			virtual int getResult(){
				return mA + mB;
			}
			   

};



//减法计算器类
class MinuteCaculator :public AbstractCaculator{
public:
	int mA;
	int mB;

public:
	virtual void setOperatorNumber(int a, int b){
		this->mA = a;
		this->mB = b;
	}

	virtual int getResult(){
		return mA - mB;
	}

};

//乘法计算器类
class MultiplyCaculator :public AbstractCaculator{
public:
	int mA;
	int mB;

public:
	virtual void setOperatorNumber(int a, int b){
		this->mA = a;
		this->mB = b;
	}

	virtual int getResult(){
		return mA * mB;
	}

};

//取模计算器类，通过增加代码，而不是修改原来的
class QumoCaculator :public AbstractCaculator{
public:
	int mA;
	int mB;

public:
	virtual void setOperatorNumber(int a, int b){
		this->mA = a;
		this->mB = b;
	}

	virtual int getResult(){
		return mA % mB;
	}

};



void test01() {
	AbstractCaculator * caculator = new PlusCaculator;
	caculator->setOperatorNumber(10, 20);
	cout << "ret:" << caculator->getResult() << endl;

	 caculator = new MinuteCaculator;
	caculator->setOperatorNumber(10, 20);
	cout << "ret:" << caculator->getResult() << endl;
}

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

迪米特法则：

最小知识原则：在用户与底层的中间层之间建立中间层 即一个对象应尽量的对其他对象少了解，降低哥哥对象之间的耦合

例如:下面例子建立的中间层，在test2调用时不用具体的接触 building类

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <string>
#include <vector>

using namespace std;
//迪米特法则又叫最少知识原则


//写一个抽象类
class AbstractBuilding{
public:
	string mQulity;
public: 
	virtual void sale() = 0;
	virtual string getQuality() = 0;
};

//楼盘A 
class BuildingA :public AbstractBuilding{

public:
	BuildingA(){
		mQulity = "高品质";
	}

	virtual void sale(){
		cout << "楼盘A" << mQulity << "被售卖!" << endl;
	}

	virtual string getQuality(){
		return mQulity;
	};

};

//楼盘B 
class BuildingB :public AbstractBuilding{

public:
	BuildingB(){
		mQulity = "低品质";
	}

	virtual void sale(){
		cout << "楼盘A" << mQulity << "被售卖!" << endl;
	}
	virtual string getQuality(){
		return mQulity;
	};

};








void test01() {
	BuildingA*ba = new BuildingA; 
	if (ba->mQulity == "低品质"){
		ba->sale();
	}
	BuildingB*bb = new BuildingB;
	if (bb->mQulity == "低品质"){
		bb->sale();
	}
}

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

		building = new BuildingB;
		vBuilding.push_back(building);
	}
	~Mediator(){
		for (
			vector<AbstractBuilding*>::iterator it = vBuilding.begin();
			it != vBuilding.end();
			it++
			){
			if (*it != NULL) delete *it;
		}
	}
	//对外提供接口
	AbstractBuilding* findMyBuilding(string quality){
	
		for (
			vector<AbstractBuilding*>::iterator it = vBuilding.begin();
			it != vBuilding.end();
			it++
			){
			//两个if任选一个
			//if ((*it)->getQuality() == quality) return *it;

			
			if ((*it)->mQulity == quality) return *it;
			
		}
			return NULL;
	}


};


//客户端
void test02(){
	Mediator*mediator = new Mediator;
	AbstractBuilding*building = mediator->findMyBuilding("高品质");
	if (building != NULL){
		building->sale();
	}
	else{
		cout << "没有符合您条件的楼盘！" << endl;
	}

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




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

合成复用原则：

使用继承比较复杂情况，不使用继承，可以优先使用组合

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

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;
	}
}; 

/*
class Person1 : public Tuolaji{
public: 
	void Doufeng(){//兜风
			run();
	}
 };

class Person2 : public Dazhong{
public:
	void Doufeng(){//兜风
		run();
	}
};
*/
//可以使用组合
class Person{
public:
	AbstractCar*car;

public:

	void setCar(AbstractCar*car){
		this->car = car;
	}
	void Doufeng(){
		this->car->run();
		
	}
	~Person(){
		if (this->car != NULL) {
			delete this->car;
                        this->car == null;
		}
	}

};
void test01()
{
	Person* p = new Person;
	p->setCar(new Dazhong);
	p->Doufeng();


	p->setCar(new Tuolaji);
	p->Doufeng();
	delete p;
}

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