=======================================

一 单一职责原则

1 类对外只提供一种功能,

当然这是理想化,意思就是说一个类不要写太多的方法.

2 单一职责例子

上面假如我们定义了一个clothes类,有2个方法,分别是工作方式

穿什么衣服衣服和逛街方式穿什么衣服,

但是如果我想在工作的时候穿下逛街时候的衣服,休闲一下,那么改变

工作方式里的功能,变成和逛街方式里一样的代码

那么如果第二个程序员过来一看,这俩个功能的代码是一样的,那就懵

逼了.

而如果我们把2个功能分别放在2个类里并且方法名都改成一样的,比

如说 穿衣(),就可以解决这个问题

这就是单一原则,尽可能的一个类少放方法

二 开闭原则

1 尽可能不修改原有的代码

如果一个类不满足需求了,尽可能的不去修改类,而是通过增加代码的

方式去满足要求

2 开闭原则例子

假如有一个银行业务员的类,具有 存款 支付 转账 3个功能,现在需要加

入一个办理基金功能,我们可以在类里再加一个办理基金的函数

但是这违背了开闭原则,因为类有可能是给其它人使用的,你不可能天

天修改类

所以可以把银行业务员的类抽象出来,只留一个work的接口

然后让不同指责的类去继承并实现银行业务员的类,这样就能只增加代

码,而不去修改类

三 依赖倒转原则

1 尽可能的写接口编程

2 依赖倒转原则例子,图说不清楚,直接上代码,这是一个电脑组装的例

子

#include <iostream>

using namespace std;

//高级逻辑层,
//Computer是一个核心,他提供功能,但是这些功能需要3个硬件
//但是硬件又不能指定哪个产商的硬件,所以干脆就定义3个接口
//让能够实现这个接口功能的产商都能用这个功能

class CPU
{
public:
	virtual void calculate() = 0;
};

class Hard_disk
{
public:
	virtual void save() = 0;
};

class mouse
{
public:
	virtual void move_to() = 0;
};

//核心
//我们只需要使用这3个接口帮我们实现的功能即可
class Computer
{
public:
	Computer(CPU* mycpu, Hard_disk* mydisk, mouse* mymouse)
	{
		this->mycpu = mycpu;
		this->mydisk = mydisk;
		this->mymouse = mymouse;
	}

	void run()
	{
		mycpu->calculate();
		mydisk->save();
		mymouse->move_to();
	}

private:
	CPU* mycpu;
	Hard_disk* mydisk;
	mouse* mymouse;
};


//实现层
//不同的产商去实现3个接口
class Inter_Cpu:public CPU
{
public:
	virtual void calculate() override
	{
		cout << "Inter_Cpu" << endl;
	}
};

class west_disk:public Hard_disk
{
public:
	virtual void save() override
	{
		cout << "west_disk" << endl;
	}
};

class leishe :public mouse
{
public:

	virtual void move_to() override
	{
		cout << "leishe" << endl;
	}

};

//业务层
//用来创建和调用computer的功能
int main()
{
	CPU *c1 = new Inter_Cpu;
	Hard_disk *h1 = new west_disk;
	mouse *m1 = new leishe;

	Computer *cp1 = new Computer(c1, h1, m1);
	cp1->run();

}