設計模式2 面向?qū)ο笤O計原則

面向?qū)ο笤O計原則 
原則的目的
面向?qū)ο笤O計原創(chuàng)表 

單一職責原則案例
開閉原則 案例
依賴倒轉(zhuǎn)原則 案例

面向?qū)ο笤O計原則 

對于面向?qū)ο筌浖到y(tǒng)的設計而言，在支持可維護性的同時，提高系統(tǒng)的可復用性是一個至關重要的問題，如何同時提高一個軟件系統(tǒng)的可維護性和可復用性是面向?qū)ο笤O計需要解決的核心問題之一。在面向?qū)ο笤O計中，可維護性的復用是以設計原則為基礎的。每一個原則都蘊含一些面向?qū)ο笤O計的思想，可以從不同的角度提升一個軟件結(jié)構(gòu)的設計水平。 

面向?qū)ο笤O計原則為支持可維護性復用而誕生，這些原則蘊含在很多設計模式中，它們是從許多設計方案中總結(jié)出的指導性原則。面向?qū)ο笤O計原則也是我們用于評價一個設計模式的使用效果的重要指標之一。 

原則的目的： 高內(nèi)聚，低耦合 

面向?qū)ο笤O計原創(chuàng)表 

1,單一職責原則:

如果將每個類的方法分離出來,就能夠保證每個類的指針單一.

提高了安全性.

提高了可維護性

提高了可讀性.

單一原則,示范1,

chunli@linux:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿休閑的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.shoping();
	return 0;
}
chunli@linux:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿休閑的衣服
chunli@linux:~/design$

但是這個項目,老程序員走了,新的程序員接手,要求上班穿休閑的衣服

于是代碼就變成了這樣的:

chunli@linux:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
chunli@linux:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿正式的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.shoping();
	return 0;
}
chunli@linux:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
chunli@linux:~/design$

后來又有新的程序員看著這兩行的功能是一樣 的,于是又改成這樣的

chunli@linux:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class clothes
{
public:
	void working()
	{
		cout << "穿正式的衣服" <<endl;
	}
	void shoping()
	{
		cout << "穿正式的衣服" <<endl;
	}
};

int main()
{
	clothes c ;
	c.working();
	c.working();
	return 0;
}
chunli@linux:~/design$ g++ main.cpp && ./a.out 
穿正式的衣服
穿正式的衣服
chunli@linux:~/design$

再來新手接這樣的項目就徹底暈了.....

寫成單一原則,這樣就不用搞來搞去了,不要修改已經(jīng)寫好的代碼.

chunli@linux:~/design$ cat main.cpp 
#include <iostream>
using namespace std;

class ClothesWoring
{
public:
	void style()
	{
		cout << "穿正裝" << endl;
	}
};
class ClothesShoping
{
public:
	void style()
	{
		cout << "穿休閑裝" << endl;
	}
};
int main()
{
	ClothesShoping cs;
	ClothesWoring cw;
	cs.style();
	cw.style();

	return 0;
}
chunli@linux:~/design$ g++ main.cpp && ./a.out 
穿休閑裝
穿正裝
chunli@linux:~/design$

單一職責原則:

如果將每個類的方法分離出來,就能夠保證每個類的指針單一.

提高了安全性.

提高了可維護性

提高了可讀性.

2,開閉原則案例:

類的改動是添加代碼,而不是修改源代碼

原始的代碼:
chunli@linux:~$ cat main.cpp 
//設計模式 開閉原則
//定義:類的改動是增加代碼進行的,而不是修改源代碼


#include<iostream>
using namespace std;
class Banker
{
public:
	void save()
	{
		cout << "存款" << endl;
	}
	void pay()
	{
		cout <<"付款" << endl;
	}
	void transfer()
	{
		cout << "轉(zhuǎn)賬 " <<endl;
	}
};

int main()
{
	Banker B;
	B.save();
	B.pay();
	B.transfer();
	return 0;
}
chunli@linux:~$ g++ main.cpp && ./a.out 
存款
付款
轉(zhuǎn)賬 
chunli@linux:~$

代碼優(yōu)化,

chunli@linux:~$ cat main.cpp 
//設計模式 開閉原則
//定義:類的改動是增加代碼進行的,而不是修改源代碼


#include<iostream>
using namespace std;
//////////////////////////////////////////////////////////////////
class AbstractBanker //抽象類
{
public:
	//AbstractBanker() = 0;
	virtual ~AbstractBanker(){};
	virtual void work() = 0;//接口
};
// // // // // // // // // // // // // // // // // // // // // //

class SaveBanker:public AbstractBanker //存款,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "存款方法" << endl;
	}
};

class PayBanker:public AbstractBanker //支付,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "支付方法" << endl;
	}
};

class TransferBanker:public AbstractBanker //轉(zhuǎn)賬,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "轉(zhuǎn)賬方法" << endl;
	}
};
/////////////////////////////////////////////////////////

int main()
{
	SaveBanker* sb = new SaveBanker;
	sb->work();
	delete sb;

	PayBanker  *pb = new PayBanker;
	pb->work();
	delete sb;

	TransferBanker *tb = new TransferBanker;
	tb->work();
	delete tb;

	return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
存款方法
支付方法
轉(zhuǎn)賬方法
chunli@linux:~$

新增 基金辦理 需求,不再需要修改源代碼

chunli@linux:~$ cat main.cpp 
//設計模式 開閉原則
//定義:類的改動是增加代碼進行的,而不是修改源代碼


#include<iostream>
using namespace std;
//////////////////////////////////////////////////////////////////
class AbstractBanker //抽象類
{
public:
	//AbstractBanker() = 0;
	virtual ~AbstractBanker(){};
	virtual void work() = 0;//接口
};
// // // // // // // // // // // // // // // // // // // // // //

class SaveBanker:public AbstractBanker //存款,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "存款方法" << endl;
	}
};

class PayBanker:public AbstractBanker //支付,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "支付方法" << endl;
	}
};

class TransferBanker:public AbstractBanker //轉(zhuǎn)賬,繼承抽象類
{
public:
	virtual void work()
	{
		cout << "轉(zhuǎn)賬方法" << endl;
	}
};

class FundBanker:public AbstractBanker //新增基金,繼承抽象類,不需要修改其他類的源代碼
{
public:
	virtual void work()
	{
		cout << "基金辦理" << endl;
	}
};
/////////////////////////////////////////////////////////

int main()
{
	SaveBanker* sb = new SaveBanker;
	sb->work();
	delete sb;

	PayBanker  *pb = new PayBanker;
	pb->work();
	delete sb;

	TransferBanker *tb = new TransferBanker;
	tb->work();
	delete tb;
	FundBanker *fb = new FundBanker;
	fb->work();
	delete fb;

	return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
存款方法
支付方法
轉(zhuǎn)賬方法
基金辦理
chunli@linux:~$

總結(jié):

開閉原則: 安全穩(wěn)定,可維護.

3,依賴倒轉(zhuǎn)原則案例:

張三上班開奔馳

chunli@linux:~$ cat main.cpp 
//設計模式:依賴倒轉(zhuǎn)

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "奔馳啟動了" << endl;
	}
};

class Zhangsan
{
public:
	void driveBenz(Benz *car)
	{
		cout << "張三 開車上班"<< endl;
		car->run();
	}
};

int main()
{
	Benz *benz = new Benz;
	Zhangsan *z3 = new Zhangsan;
	z3->driveBenz(benz);
	
	return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
張三 開車上班
奔馳啟動了
chunli@linux:~$

張三還可能開寶馬上班

chunli@linux:~$ cat main.cpp 
//設計模式:依賴倒轉(zhuǎn)

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "奔馳啟動了" << endl;
	}
};

class BMW
{
public:
	void run()
	{
		cout << "寶馬啟動了" << endl;
	}
};

class Zhangsan
{
public:
	void driveBenz(Benz *car)
	{
		cout << "張三 開車上班"<< endl;
		car->run();
	}
	void driveBMW(BMW *car)
	{
		cout << "張三 開車上班"<< endl;
		car->run();
	}
};

int main()
{
	Benz *benz = new Benz;
	Zhangsan *z3 = new Zhangsan;
	z3->driveBenz(benz);


	BMW *bmw = new BMW;
	z3->driveBMW(bmw);
	
	return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
張三 開車上班
奔馳啟動了
張三 開車上班
寶馬啟動了
chunli@linux:~$

-------------------------------

業(yè)務逐漸復雜,那大眾呢?越來越多的的呢?

越來越亂............

------------------------------------------

將業(yè)務層和實現(xiàn)層 通過抽象層 隔離,解耦合 

chunli@linux:~$ cat main.cpp 
//設計模式:依賴倒轉(zhuǎn)
//將業(yè)務層和實現(xiàn)層 通過抽象層 隔離,解耦合 

#include<iostream>
using namespace std;
//////////抽象層 車  人 ////////////////////////////
class Car
{
public:
	virtual void run() = 0;
	virtual ~Car(){}
};

class Driver
{
public:
	virtual void drive(Car *car) = 0;
	virtual ~Driver(){}
};

////////    實現(xiàn)層        /////////////////////////
class ZhangSan:public Driver
{
public:
	virtual void drive(Car *car)
	{
		cout << "張三開車上班了" << endl;
		car->run();
	}
};
class LiSi:public Driver
{
public:
	virtual void drive(Car *car)
	{
		cout << "李四 開車上班了" << endl;
		car->run();
	}
};


class Benz:public Car
{
public:
	virtual void run()
	{
		cout << "Benz 啟動了" << endl;
	};
};

class BMW:public Car
{
public:
	virtual void run()
	{
		cout << "BMW 啟動了" << endl;
	};
};
///////////// 主函數(shù) ////////////////////////////////////
int main()
{
	//讓張三開奔馳
	Car * benz = new Benz;
	Driver *zhangsan = new ZhangSan;
	zhangsan->drive(benz);

	//讓李四上班 開寶馬
	Car *bmw = new BMW;
	Driver *lisi = new LiSi;
	lisi->drive(bmw);  


	return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
張三開車上班了
Benz 啟動了
李四 開車上班了
BMW 啟動了
chunli@linux:~$

依賴倒轉(zhuǎn)原則,電腦組裝案例:

抽象層:CPU,顯卡,內(nèi)存

框架層:組合CPU,顯卡,內(nèi)存

chunli@linux:~$ cat main.cpp 
//設計模式:依賴倒轉(zhuǎn),電腦組裝案例
#include<iostream>
using namespace std;

//抽象類
class CPU
{
public:
	virtual void caculate() = 0;
	virtual ~CPU(){}
};

class Card
{
public:
        virtual void display() = 0;
	virtual ~Card(){}
};

class Memmory
{
public:
	virtual void storage() = 0;
	virtual ~Memmory(){}
};

//架構(gòu)類
class Computer
{
public:
	Computer(CPU* cpu,Card* card,Memmory* mem)
	{
		this->cpu = cpu;
		this->card = card;
		this->mem = mem;
	}
	virtual ~Computer() {};
	void work()
	{
		cpu->caculate();
		card->display();
		mem->storage();
	}
private:
	CPU *cpu;
	Card *card;
	Memmory* mem;
};
//////實現(xiàn)層//////////////////////////////////
class IntelCPU:public CPU
{
public:
	virtual void caculate()
	{
		cout << "intel CPU working" << endl;
	}
};

class NvidiaCard:public Card
{
public:
	virtual void display()
	{
		cout << "nvidia card  working" << endl;
	}
};
class KingSton:public Memmory
{
public:
	virtual void storage()
	{
		cout << "KingSton mem  working" << endl;
	}
};
/////////  主函數(shù) ///////////////////
int main()
{

	CPU* cpu 	= new IntelCPU;
	Card* card 	= new NvidiaCard;
	Memmory* mem	= new KingSton;

	Computer* computer = new Computer(cpu,card,mem);
	computer->work();
	return 0;
}





chunli@linux:~$ g++ main.cpp -Wall && ./a.out 
intel CPU working
nvidia card  working
KingSton mem  working
chunli@linux:~$

里氏代換原則:略

接口隔離原則:

合成復用原則:繼承,組合,依賴

能用組合不用繼承

迪米特法則: