溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
面向對象設計原則 原則的目的 面向對象設計原創表 單一職責原則案例 開閉原則 案例 依賴倒轉原則 案例
面向對象設計原則
對于面向對象軟件系統的設計而言，在支持可維護性的同時，提高系統的可復用性是一個至關重要的問題，如何同時提高一個軟件系統的可維護性和可復用性是面向對象設計需要解決的核心問題之一。在面向對象設計中，可維護性的復用是以設計原則為基礎的。每一個原則都蘊含一些面向對象設計的思想，可以從不同的角度提升一個軟件結構的設計水平。
面向對象設計原則為支持可維護性復用而誕生，這些原則蘊含在很多設計模式中，它們是從許多設計方案中總結出的指導性原則。面向對象設計原則也是我們用于評價一個設計模式的使用效果的重要指標之一。
原則的目的： 高內聚，低耦合
面向對象設計原創表
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$再來新手接這樣的項目就徹底暈了.....
寫成單一原則,這樣就不用搞來搞去了,不要修改已經寫好的代碼.
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 << "轉賬 " <<endl;
}
};
int main()
{
Banker B;
B.save();
B.pay();
B.transfer();
return 0;
}
chunli@linux:~$ g++ main.cpp && ./a.out
存款
付款
轉賬
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 //轉賬,繼承抽象類
{
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;
return 0;
}
chunli@linux:~$ g++ main.cpp -Wall && ./a.out
存款方法
支付方法
轉賬方法
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 //轉賬,繼承抽象類
{
public:
virtual void work()
{
cout << "轉賬方法" << 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
存款方法
支付方法
轉賬方法
基金辦理
chunli@linux:~$總結:
開閉原則: 安全穩定,可維護.
3,依賴倒轉原則案例:
張三上班開奔馳
chunli@linux:~$ cat main.cpp
//設計模式:依賴倒轉
#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
//設計模式:依賴倒轉
#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:~$-------------------------------
業務逐漸復雜,那大眾呢?越來越多的的呢?
越來越亂............
------------------------------------------
將業務層和實現層 通過抽象層 隔離,解耦合
chunli@linux:~$ cat main.cpp
//設計模式:依賴倒轉
//將業務層和實現層 通過抽象層 隔離,解耦合
#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(){}
};
//////// 實現層 /////////////////////////
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;
};
};
///////////// 主函數 ////////////////////////////////////
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:~$依賴倒轉原則,電腦組裝案例:
抽象層:CPU,顯卡,內存
框架層:組合CPU,顯卡,內存
chunli@linux:~$ cat main.cpp
//設計模式:依賴倒轉,電腦組裝案例
#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(){}
};
//架構類
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;
};
//////實現層//////////////////////////////////
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;
}
};
///////// 主函數 ///////////////////
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:~$里氏代換原則:略
接口隔離原則:
合成復用原則:繼承,組合,依賴
能用組合不用繼承
迪米特法則:
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
