午夜婷婷五月天欧美在线a,操逼大片操逼大片,黄色日韩无字久久大香

[導讀]大家好，明天就是周五了！有小部分朋友就可以喜迎周末了。經(jīng)過一周的工作是不是疲憊不堪？快來讀讀我的文章充充電吧~ （沒時間的可以先收藏留著周末看看哈）今天程序喵和大家分享下設計模式中創(chuàng)建型模式的第二類：工廠模式工廠模式大體可

大家好，明天就是周五了！有小部分朋友就可以喜迎周末了。
經(jīng)過一周的工作是不是疲憊不堪？
快來讀讀我的文章充充電吧~
（沒時間的可以先 收藏 留著周末看看哈）

今天程序喵和大家分享下設計模式中創(chuàng)建型模式的第二類：工廠模式

工廠模式大體可以分為

●簡單工廠模式

●工廠方法模式

●抽象工廠模式

01 簡單工廠方法

簡單工廠方法可能是最常見的工廠類創(chuàng)建型模式了，其中有幾個角色，一個是抽象產(chǎn)品角色，一個是具體產(chǎn)品角色，多個具體產(chǎn)品都可以。抽象成同一個抽象產(chǎn)品。拿操作系統(tǒng)舉例，操作系統(tǒng)作為一個抽象產(chǎn)品，它有幾種具體產(chǎn)品角色，有Windows操作系統(tǒng)，有Android操作系統(tǒng)，有iOS操作系統(tǒng)。有一個操作系統(tǒng)的工廠，工廠可以根據(jù)不同的需求生產(chǎn)出不同內核的操作系統(tǒng)，這個操作系統(tǒng)的工廠就是最后一個角色：工廠角色。

#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball {public: Ball() {}   virtual ~Ball() {}
virtual void Play() {}};
class BasketBall : public Ball {public: void Play() override { std::cout << "play basketball \n"; }};
class SocketBall : public Ball {public: void Play() override { std::cout << "play socketball \n"; }};
class SimpleFactory {public: static Ball* CreateBall(BallEnum type);};
Ball* SimpleFactory::CreateBall(BallEnum type) { switch (type) { case BallEnum::BasketBall: return new BasketBall(); case BallEnum::SocketBall: return new SocketBall(); } return nullptr;}
int main() { Ball* basket = SimpleFactory::CreateBall(BallEnum::BasketBall); basket->Play(); Ball* socket = SimpleFactory::CreateBall(BallEnum::SocketBall); socket->Play();   return 0;}

在簡單工廠方法中，有一個專門的工廠類，根據(jù)不同的參數(shù)返回不同具體產(chǎn)品類的實例，這些具體產(chǎn)品可以抽象出同一個抽象產(chǎn)品，即有一個共同的父類。通過上述代碼您可能也看到了簡單工廠方法的優(yōu)點，實現(xiàn)了對象的創(chuàng)建和使用邏輯分離，只需要傳入不同參數(shù)，就可以獲得特定具體類的實例。但簡單工廠方法也有些缺點，當增加了新的產(chǎn)品，就需要修改工廠類的創(chuàng)建邏輯，如果產(chǎn)品類型較多，就可能造成工廠類邏輯過于復雜，不利于系統(tǒng)的維護，適用于具體產(chǎn)品類型比較少并且以后基本不會新加類型的場景，這樣工廠類業(yè)務邏輯不會太過復雜。

02 工廠方法模式

為了解決上面簡單工廠方法模式的缺點，進一步抽象出了工廠方法模式，工廠類不再負責所有產(chǎn)品的構建，每一個具體產(chǎn)品都有一個對應的工廠，這樣在新加產(chǎn)品時就不會改動已有工廠類的創(chuàng)建邏輯。這些工廠也會抽象出一個抽象工廠?？梢岳斫鉃橛兴姆N角色，抽象產(chǎn)品，具體產(chǎn)品，抽象工廠，具體工廠，其實就是把簡單工廠模式中的工廠類做進一步抽象，看代碼吧：

#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball { public: Ball() {} virtual ~Ball() {}
 virtual void Play() {}};
class BasketBall : public Ball { public: void Play() override { std::cout << "play basketball \n"; }};
class SocketBall : public Ball { public: void Play() override { std::cout << "play socketball \n"; }};
class FactoryBase { public: virtual ~FactoryBase() {} virtual Ball* CreateBall() = 0;};
class BasketBallFactory : public FactoryBase { public: Ball* CreateBall() override { return new BasketBall(); }};
class SocketBallFactory : public FactoryBase { public: Ball* CreateBall() override { return new SocketBall(); }};
int main() { FactoryBase* factory; BallEnum ball_type = BallEnum::SocketBall; switch (ball_type) { case BallEnum::BasketBall: factory = new BasketBallFactory(); break; case BallEnum::SocketBall: factory = new SocketBallFactory(); break; } Ball* ball = factory->CreateBall(); ball->Play(); return 0;}

工廠模式提高了系統(tǒng)的可擴展性，完全符合開閉原則，當新加具體產(chǎn)品時，完全不會對已有系統(tǒng)有任何修改。當不知道以后會有多少具體產(chǎn)品時可以考慮使用工廠模式，因為不會降低現(xiàn)有系統(tǒng)的穩(wěn)定性。但是它也有缺點，每當新加一個產(chǎn)品時，不僅需要新加一個對應的產(chǎn)品類，同時還需要新加一個此產(chǎn)品對應的工廠，系統(tǒng)的復雜度比較高。怎么解決呢，可以再抽象一下：

03 抽象工廠模式

在工廠方法中，每一個抽象產(chǎn)品都會有一個抽象工廠，這樣新增一個產(chǎn)品時都會新增兩個類，一個是具體產(chǎn)品類，一個是具體工廠類，我們可以考慮多個抽象產(chǎn)品對應一個抽象工廠，這樣可以有效減少具體工廠類的個數(shù)，見如下代碼：

#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball { public: Ball() {} virtual ~Ball() {}
 virtual void Play() {}};
class BasketBall : public Ball { public: void Play() override { std::cout << "play basketball \n"; }};
class SocketBall : public Ball { public: void Play() override { std::cout << "play socketball \n"; }};
class Player { public: Player() {} virtual ~Player() {} virtual void Name() {}};
class BasketBallPlayer : public Player { public: void Name() override { std::cout << "BasketBall player \n"; }};
class SocketBallPlayer : public Player { public: void Name() override { std::cout << "SocketBall player \n"; }};
class FactoryBase { public: virtual ~FactoryBase() {} virtual Ball* CreateBall() = 0; virtual Player* CreatePlayer() = 0;};
class BasketBallFactory : public FactoryBase { public: Ball* CreateBall() override { return new BasketBall(); } Player* CreatePlayer() override { return new BasketBallPlayer(); }};
class SocketBallFactory : public FactoryBase { public: Ball* CreateBall() override { return new SocketBall(); } Player* CreatePlayer() override { return new SocketBallPlayer(); }};
int main() { FactoryBase* factory; BallEnum ball_type = BallEnum::SocketBall; switch (ball_type) { case BallEnum::BasketBall: factory = new BasketBallFactory(); break; case BallEnum::SocketBall: factory = new SocketBallFactory(); break; } Ball* ball = factory->CreateBall(); Player* player = factory->CreatePlayer(); ball->Play(); player->Name(); return 0;}

總結

系統(tǒng)的復雜度不會被消除，只能被轉移。系統(tǒng)總會有穩(wěn)定部分和不穩(wěn)定部分，只是我們要合理選擇好邊界，認真思考，考慮好將哪部分打造成穩(wěn)定部分，哪部分打造成不穩(wěn)定部分。簡單工廠方法模式中if-else的邏輯在工廠類里，如果這里在新增一個產(chǎn)品時有bug可能導致所有產(chǎn)品都創(chuàng)建失敗，這里是不穩(wěn)定部分，所以有了工廠方法模式，將工廠類內部打造成穩(wěn)定部分，將不穩(wěn)定的邏輯轉移到外面。

往期推薦

免責聲明：本文內容由21ic獲得授權后發(fā)布，版權歸原作者所有，本平臺僅提供信息存儲服務。文章僅代表作者個人觀點，不代表本平臺立場，如有問題，請聯(lián)系我們，謝謝！

設計模式之工廠模式