设计模式四个原则代码实现

1. 开闭原则

对增加功能开，对修改原代码闭

#include<iostream>
using namespace std;

#if 0
//不用开闭原则
//计算
class Caculator
{
public:
	Caculator(int a, int b, string oper)
	{
		this->m_a = a;
		this->m_b = b;
		this->m_operator = oper;
	}
	
	int getResult()
	{
		if(m_operator.compare("+") == 0)
		{
			return m_a + m_b;
		}
		else if(m_operator.compare("-") == 0)
		{
			return m_a - m_b;
		}

	}
private:
	int m_a;
	int m_b;
	string m_operator;
};

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


//如果增加新功能就需要修改getRsult方法，有报错的可能，而增加新功能应该保证不影响其他已经完成的功能
#endif


//抽象类
class AbstractCaculator
{
public:
	virtual int getResult() = 0;
	virtual void setNum(int, int)= 0;
};

//加法
class Plus :public AbstractCaculator
{
public:
	virtual void setNum(int a, int b)
	{
		this->m_a = a;
		this->m_b = b;
	}
	virtual int getResult()
	{
		return m_a+m_b;
	}
private:
	int m_a;
	int m_b;

};
//减法
class Minus :public AbstractCaculator
{
public:
	virtual void setNum(int a, int b)
	{
		this->m_a = a;
		this->m_b = b;
	}
	virtual int getResult()
	{
		return m_a-m_b;
	}
private:
	int m_a;
	int m_b;

};
//加新功能，源代码安全

void test02()
{
	AbstractCaculator* caculator = new Plus;
	caculator->setNum(10,20);
	cout<<caculator->getResult()<<endl;
	delete caculator;
	//AbstractCaculator* caculator = new Minus;


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

1. 迪米特原则

系统之间相互调用的时候，彼此的信息知道的越少越好，减少耦合性

#include<iostream>
#include<string>
#include<vector>
using namespace std;


class AbstractBuilding
{
public:
	virtual void sale() = 0;
	string m_Quality;
};


//A楼
class BuildingA : public AbstractBuilding
{
public:
	BuildingA ()
	{
		m_Quality = "好";
	}
	virtual void sale()
	{
		cout<<"楼A"<< m_Quality<<" ， 买了"<<endl;
	}
};

//B楼
class BuildingB : public AbstractBuilding
{
public:
	BuildingB()
	{
		m_Quality = "一般";
	}
	virtual void sale()
	{
		cout<<"楼B"<<m_Quality<<" ， 买了"<<endl;
	}

};
#if 0
//用户想选一个一般的
void test01()
{
	BuildingA* ba = new BuildingA;
	if(ba->m_Quality == "一般")
	{
		ba->sale();
	}
	BuildingB* bb = new BuildingB;
	if(bb->m_Quality == "一般")
	{
		bb->sale();
	}
}
//每个类（楼）都要去调用，耦合性太强
#endif


//考虑中间类 让中介去管理所有的楼， 用户直接与中介打交道，中介给用户所需要的信息
class Mediator
{
public:
	Mediator()
	{
		AbstractBuilding* building = new BuildingA;
		vBuilding.push_back(building);
		building = new BuildingB;
		vBuilding.push_back(building);
	}

	//对外提供一个接口,让用户去找
	AbstractBuilding* findBuilding(string quality)
	{
		for(vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end();it++)
		{
			if((*it)->m_Quality == quality)
			{
				return *it;
			}
			else return NULL;

		}

	}


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

};

void test03()
{
	Mediator* mediator = new Mediator;
	AbstractBuilding* building = mediator->findBuilding("一般");//让中介去找到想要的一般的楼
	if(building != NULL)
	{
		building->sale();
	}
	else
		cout<<"没有符合该条件的楼"<<endl;

}

//不需要和具体类打交道了

int main03()
{
	//test01();
	test03();//ok
	return 0;
}

3. 合成复用原则

继承和组合，优先使用组合

#include<iostream>
using namespace std;

class AbstractCar
{
public:
	virtual void run() = 0;
};

class car1 : public AbstractCar
{
public:
	virtual void run()
	{
		cout<<"car1 run..."<<endl;
	}
private:

};


class car2 : public AbstractCar
{
public:
	virtual void run()
	{
		cout<<"car2 run..."<<endl;
	}
private:

};

//每一种具体情况都要重新写类，
#if 0
class person : public car2
{
public:
	void DF()
	{run();}
};
class personB:public car1
{};
#endif




//使用组合

class Person
{
public:
	void setCar(AbstractCar* car)
	{
		this->car = car;
	}
	void DF()
	{
		this->car->run();
	}
	~Person()
	{
		if(this->car!= NULL)
		{
			delete this->car;
		}
	}
public:
	AbstractCar* car;//一个抽象的汽车类
};
void test04()
{
	Person* p = new Person;
	p->setCar(new car1);
	p->DF();
	//delete 再set ok
}


int main04()
{
	test04();
	return 0;
}

4. 依赖倒转原则

依赖抽象层

#include<iostream>
using namespace std;


#if 0
class BankWorker
{
public:
	void saveService()
	{
		cout<<"存款..."<<endl;
	}
	void payService()
	{
		cout<<"支付..."<<endl;
	}
};

void doSave(BankWorker* worker)
{
	worker->saveService();
}
void doPay(BankWorker* worker)
{
	worker->payService();
}

void test()
{
	BankWorker* worker = new BankWorker;
	doSave(worker);
	doPay(worker);
}
//一层依赖一层
#endif


//首先第一个worker类职责太多


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

 //第一层结束，分开

 void doMyBusiness(AbstractWorker* worker)//依赖于抽象层，传进来是办什么业务的人就办什么业务
 {
	 worker->doBusiness();
 }
 //中间层


 void test05()
 {
	 AbstractWorker* pay = new PayBankWorker;
	 doMyBusiness(pay);
 }
 int main()
 {
	 test05();

	 return 0;
 }