设计模式2——面向对象设计原则

在一定的环境下，用固定套路解决问题
设计模式的基础：多态

软件设计模式的种类

GoF设计模式有23个，如果再加上一个简单工厂模式一共24个。包括

软件设计模式有什么用？

学习设计模式有助于更加深入的理解面向对象思想，让你知道：

1. 如何将代码分散在几个不同的类中?
2. 为什么要有“接口”?
3. 何谓针对抽象编程?
4. 何时不应该使用继承?
5. 如果不修改源代码增加新功能?
6. 更好地阅读和理解现有类库与其他系统中的源代码。

面向对象设计原则

对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的可
复用性是一个至关重要的问题,如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。在面向对象设计中，可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，可以从不同的角度提升一个软件结构的设计水平。

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

1、面向对象设计原则表

• 单一原则：类只提供一个功能
• 开闭原则（开放-封闭原则）：类的改动是增加代码而不是修改源代码
• 里氏代换原则：任何抽象类出现的地方都可以用其他的实现类进行替换
• 依赖倒转原则：依赖于抽象而不是具体实现，也就是针对接口编程。
• 接口隔离原则：不要把所有功能都放到一个接口里面
• 合成复用原则：使用继承导致父类的任何变换都会影响到子类，如果使用对象组合或者聚合会降低这种影响
• 迪米特法则：一个对象应该对另一个对象尽可能少的了解

1、开闭原则

对扩展开放，对修改关闭，增加功能是通过增加代码来实现的而不是修改源代码。如果修改就可能出错。

以一个计算器为例，一般的将加减乘除放到一个类里面，如果这样写的话增加功能会修改源代码

如果使用开闭原则

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


//中介类
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;
}

3、合成复用原则

针对具体类，继承和组合优先使用组合

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

//笨方法，针对具体类 不适用继承
#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 != nullptr) {
			delete this->car;
			this->car = nullptr;
		}
	}

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

4、依赖倒转原则

穿透过程式设计使的高层模块依赖低层次的模块，抽象层依赖于具体的层次。这样一旦底层模块发生改变相应的高层模块可能会有影响。

改变后

以下面银行为例子，银行工作人员能够做存款、支付、转账业务， 这是属于底层业务，然后往上封装形成专门办理存款、支付、转账的方法，这是属于中层模块，然后被高层调用

使用依赖倒转后，中间层是传入抽象类，然后类里调用方法，这时候高层只需要根据具体需要传入各种类型的子类就能够调用子类重写的方法。

#include <iostream>
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;
}