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

面向对象设计原则

原则的目的：高内聚，低耦合

1. 单一职责原则

类的职责单一，对外只提供一种功能，而引起类变化的原因都应该只有一个。

2. 开闭原则

对扩展开放，对修改关闭；增加功能是通过增加代码来实现的，而不是去修改源代码。

#include<iostream>
using namespace std;

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

//写一个抽象类
class AbstractCaculator
{
public:
	virtual int getResult() = 0;
	virtual void setOperatorNumber(int a, int b) = 0;
};

//加法计算类
class AddCaculator :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 SubCaculator :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 MolCaculator :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 MulCaculator :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* caculator = new AddCaculator;
	caculator->setOperatorNumber(10, 20);
	cout << "ret:" << caculator->getResult() << endl;
	delete caculator;

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

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

3. 里氏代换原则

任何抽象类出现的地方都可以用他的实现类进行替换，实际就是虚拟机制，语言级别实现面向对象功能。 

4. 依赖倒转原则

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

传统方式：

#include<iostream>
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 test04() {
	BankWorker* worker = new BankWorker;
	doSaveBussiness(worker);  //办理存款业务
	doPayBussiness(worker); //办理支付业务
	doTranferBussiness(worker); //办理转账业务
}

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

依赖倒转原则： 

#include<iostream>
using namespace std;

//银行工作人员
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;
	}
};

//专门办理转账业务的工作人员
class TransferBankWorker :public AbstractWorker
{
public:
	virtual void doBusiness()
	{
		cout << "办理转账业务..." << endl;
	}
};

//中层业务
void doNewBussiness(AbstractWorker* worker)
{
	worker->doBusiness();
}

void test04_1()
{
	AbstractWorker* transfer = new TransferBankWorker;
	doNewBussiness(transfer);
}

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

5. 接口隔离原则

        不应该强迫用户的程序依赖他们不需要的接口方法。一个接口应该只提供一种对外功能，不应该把所有操作都封装到一个接口中去。 

6. 迪米特法则(最少知识原则) 

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

#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()
	{
		m_Quality = "高品质";
	}
	virtual void sale()
	{
		cout << "楼盘A" << m_Quality << "被售卖！" << endl;
	}
	virtual string getQuality()
	{
		return m_Quality;
	}

public:
	string m_Quality;
};

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

	virtual string getQuality()
	{
		return m_Quality;
	}
public:
	string m_Quality;
};

//客户端
void test02()
{
	BuildingA* ba = new BuildingA;
	if (ba->m_Quality == "高品质")
	{
		ba->sale();
	}

	BuildingB* bb = new BuildingB;
	if (bb->m_Quality == "低品质")
	{
		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;
			}
		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_1()
{
	Mediator* meidator = new Mediator;
	AbstractBuilding* building = meidator->findMyBuilding("高品质");
	if (building != NULL)
	{
		building->sale();
	}
	else
	{
		cout << "没有符合条件的楼盘！" << endl;
	}
}

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

7. 合成复用原则

如果使用继承，会导致父类的任何变换都可能影响到子类的行为。

如果使用对象组合，就降低了这种依赖关系。
对于继承和组合，优先使用组合。

#include<iostream>
using namespace std;

//抽象车
class AbstructCar
{
public:
	virtual void run() = 0;
};

//大众车
class Dazhong :public AbstructCar
{
public:
	virtual void run()
	{
		cout << "大众车启动" << endl;
	}
};

//拖拉机
class Tuolaji :public AbstructCar
{
public:
	virtual void run()
	{
		cout << "拖拉机启动" << endl;
	}
};

//针对具体类，不适用继承
#if 0
class Person :public Tuolaji
{
public:
	void Douofeng()
	{
		run();
	}
};

class PersonB :public Dazhong
{
public:
	void Douofeng()
	{
		run();
	}
};
#endif

//可以使用组合
class Person
{
public:
	void setCar(AbstructCar *car)
	{
		this->car = car;
	}
	void Doufeng()
	{
		this->car->run();
		if (this->car != NULL)
		{
			delete this->car;
			this->car = NULL;
		}
	}

public:
	AbstructCar* car;
};

void test03()
{
	Person* p = new Person;
	p->setCar(new Dazhong);
	p->Doufeng();
	
	p->setCar(new Tuolaji);
	p->Doufeng();

	delete p;
}

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