我的编程空间,编程开发者的网络收藏夹
学习永远不晚

设计模式之简单工厂模式、工厂模式、抽象工厂模式的对比

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

设计模式之简单工厂模式、工厂模式、抽象工厂模式的对比

前言:

设计模式已经经历了很长一段时间的发展,它们提供了软件开发过程中面临的一般问题的最佳解决方案。学习这些模式有助于经验不足的开发人员通过一种简单快捷的方式来学习软件设计。

一般我们会说设计模式一共有23种,总体来说设计模式分为三大类:

创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

今天主要是分析 简单工厂模式、工厂模式和抽象工厂模式的区别,所以这里就简单介绍一下设计模式的概念。

网上的很多资料都是在阐述着:工厂模式的好处就是解耦。相信大家对解耦这个词也不陌生,那解耦究竟有什么好处呢?

  • 1.为了提高内聚(Cohesion)和松耦合(Coupling),我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现,达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类,我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。这里带来两个问题:

客户程序员必须知道实际子类的名称(当系统复杂后,命名将是一个很不好处理的问题,为了处理可能的名字冲突,有的命名可能并不是具有很好的可读性和可记忆性,就姑且不论不同程序员千奇百怪的个人偏好了)。程序的扩展性和维护变得越来越困难。

  • 2.还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为:假设我们在类 A 中要使用到类 B,B 是一个抽象父类,在 A 中并不知道具体要实例化那一个 B 的子类,但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句,因为根本就不知道×××是什么。

以上两个问题也就引出了工厂模式的两个最重要的功能:定义创建对象的接口,封装了对象的创建;使得具体化类的工作延迟到了子类中。

对于工厂模式,为了使其能更好的解决多种情况的问题,将其分为三类:简单工厂模式(Simple Factory),工厂方法模式(Factory Method),抽象工厂模式(Abstract Factory)。GOAT 经常使用会遇到一些设计模式的使用,但是很少去细究里面的区别,这把就让我来大家分享一下,我认知中的这三种工厂模式。

简单工厂模式

我们把被创建的对象称为“产品”,把创建产品的对象称为“工厂”。如果要创建的产品不多,只要一个工厂类就可以完成,这种模式叫“简单工厂模式”。

结构定义:

是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式中包含的角色及其相应的职责如下:

工厂角色(Creator):这是简单工厂模式的核心,由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用,创建所需要的产品对象。

抽象(Product)产品角色:简单工厂模式所创建的所有对象的父类,注意,这里的父类可以是接口也可以是抽象类,它负责描述所有实例所共有的公共接口。

具体产品(Concrete Product)角色:简单工厂所创建的具体实例对象,这些具体的产品往往都拥有共同的父类。

定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

结构图如下

 

范例如下:

C++实现

  1. #include  
  2. using namespace std; 
  3.  
  4. enum Product_Type 
  5.     Product1_, 
  6.     Product2_, 
  7. }; 
  8. class AbstractProduct //抽象(Product)产品角色 
  9. public
  10.     AbstractProduct() {} 
  11.     virtual ~AbstractProduct() {} 
  12.     virtual void Show() = 0; 
  13. }; 
  14.  
  15. class Product1 : public AbstractProduct //具体产品(Concrete Product)角色 
  16. private: 
  17.      
  18. public
  19.     Product1(); 
  20.     ~Product1(); 
  21.     void Show() 
  22.     { 
  23.         std::cout<< "product1"<
  24.     } 
  25. }; 
  26.  
  27. Product1::Product1() 
  28.  
  29. Product1::~Product1() 
  30. class Product2 : public AbstractProduct //具体产品(Concrete Product)角色 
  31. private: 
  32.      
  33. public
  34.     void Show() 
  35.     { 
  36.         std::cout<< "product2"<
  37.     } 
  38. }; 
  39. class Factory  //工厂角色(Creator) 
  40. public
  41.     AbstractProduct *CreateProduct(Product_Type  type)  
  42.     { 
  43.         switch (type) 
  44.         { 
  45.         case Product1_: 
  46.              
  47.             return new Product1(); 
  48.         case Product2_: 
  49.             return new Product2(); 
  50.         default
  51.             return NULL
  52.         } 
  53.     } 
  54. }; 
  55. int main(int argc, char **argv) 
  56.     Factory *new_factory = new Factory(); 
  57.     AbstractProduct *new_product1 = new_factory->CreateProduct(Product1_); 
  58.     new_product1->Show(); 
  59.  
  60.  
  61.     AbstractProduct *new_product2 = new_factory->CreateProduct(Product2_); 
  62.     new_product2->Show(); 
  63.      
  64.     delete new_factory,new_product1,new_product2; 
  65.     new_factory = NULL;     
  66.     new_product1 = NULL;     
  67.     new_product2 = NULL;     

python实现

  1. #!/usr/bin/python3 
  2.  
  3. from enum import Enum 
  4.  
  5. ProducType = Enum(('ProducType'),('product1_','product2_','product_3')) 
  6.  
  7. class AbstractProduct(object): 
  8.     def show(self): 
  9.         pass 
  10. class Product1(AbstractProduct): 
  11.     def show(self): 
  12.         print("Product1"
  13.  
  14. class Product2(AbstractProduct): 
  15.     def show(self): 
  16.         print("Product2"
  17.  
  18. class AbcFactory(object): 
  19.     def crete_product(self): 
  20.         pass 
  21.  
  22. class Factory(AbcFactory): 
  23.     def crete_product(self,type): 
  24.         product_type = { 
  25.             ProducType.product1_ : Product1(), 
  26.             ProducType.product2_ : Product2() 
  27.         } 
  28.         return product_type.get(type,None) 
  29. if __name__ == "__main__"
  30.     new_factory = Factory() 
  31.  
  32.     product1 = new_factory.crete_product(ProducType.product1_) 
  33.     product1.show() 
  34.  
  35.     product2 = new_factory.crete_product(ProducType.product2_) 
  36.     product2.show() 

我们只需要调用不同的成员函数,工厂就帮我们实例化出想要的对象,利用上转型对象,返回父类的方式实现了结果。可以发现简单工厂模式代码简单,但不符合OCP(面向对象设计的基本原则之一 OCP(开闭原则):一个软件的实体应当对扩展开放,对修改关闭)。

总结 :

简单工厂模式最大的优点在于工厂类中可以判断客户的的选择来动态实例化相关的类,对于客户端来说,去除了具体产品的依赖。

缺点就是:很明显工厂类集中了对所有实例创建的逻辑,如果我们要新增子类或者改变方法的话,就得每次都修改工厂类里面的代码,工厂类中的代码就会十分臃肿,这就等于说我们不进开放了扩展,还开放了修改,这样就违反了开放-封闭原则。

你可能在不知不觉中已经用到过这种模式了,但简单工厂模式并不属于23种设计模式之一,下面介绍他的改进版本:工厂方法模式。

工厂模式

工厂方法模式是一种创建型设计模式, 其在父类中提供一个创建对象的方法, 允许子类决定实例化对象的类型。

[[385680]]

 

工厂方法模式的结构组成:

抽象工厂类厂(AbstractFactory):工厂方法模式的核心类,提供创建具体产品的接口,由具体工厂类实现。

具体工厂类(Producer):继承于抽象工厂,实现创建对应具体产品对象的方式。

抽象产品类(Factory):它是具体产品继承的父类(基类)。

具体产品类(Factory1):具体工厂所创建的对象,就是此类。

C++实现

  1. #include  
  2. using namespace std; 
  3. class AbstractProduct 
  4. public
  5.     AbstractProduct() {} 
  6.     virtual ~AbstractProduct() {} 
  7.     virtual void Show() = 0; 
  8. }; 
  9.  
  10. class Product1 : public AbstractProduct 
  11. private: 
  12.      
  13. public
  14.     Product1(); 
  15.     ~Product1(); 
  16.     void Show() 
  17.     { 
  18.         std::cout<< "product1"<
  19.     } 
  20. }; 
  21.  
  22. Product1::Product1() 
  23.  
  24. Product1::~Product1() 
  25. class Product2 : public AbstractProduct 
  26. private: 
  27.      
  28. public
  29.     void Show() 
  30.     { 
  31.         std::cout<< "product2"<
  32.     } 
  33. }; 
  34. class Factory 
  35. public
  36.     virtual ~Factory(){}; 
  37.     virtual AbstractProduct *CreateProduct() = 0; 
  38. }; 
  39. class Factory1 : Factory 
  40. public
  41.     AbstractProduct * CreateProduct(void) 
  42.     { 
  43.         return new Product1(); 
  44.     } 
  45.  
  46. }; 
  47. class Factory2 :Factory 
  48. public
  49.     AbstractProduct * CreateProduct(void) 
  50.     { 
  51.         return new Product2(); 
  52.     }  
  53. }; 
  54. int main(int argc, char **argv) 
  55.     Factory1 *new_factory = new Factory1(); 
  56.     AbstractProduct *new_product1 = new_factory->CreateProduct(); 
  57.     new_product1->Show(); 
  58.     delete new_factory; 
  59.     new_factory = NULL
  60.  
  61.     Factory2 * new_factory2 = new Factory2(); 
  62.     AbstractProduct *new_product2 = new_factory2->CreateProduct(); 
  63.     new_product2->Show(); 
  64.     delete new_factory2; 
  65.     new_factory2 = NULL;     

python实现

  1. #!/usr/bin/python3 
  2.  
  3.  
  4. class AbstractProduct(object): 
  5.     def show(self): 
  6.         pass 
  7. class Product1(AbstractProduct): 
  8.     def show(self): 
  9.         print("Product1"
  10.  
  11. class Product2(AbstractProduct): 
  12.     def show(self): 
  13.         print("Product2"
  14.  
  15. class Factory(object): 
  16.     def create_product(self): 
  17.         pass 
  18. class Factory1(Factory): 
  19.     def create_product(self): 
  20.         return Product1() 
  21.  
  22. class Factory2(Factory): 
  23.     def create_product(self): 
  24.         return Product2() 
  25.  
  26. if __name__ == "__main__"
  27.     new_product1 = Factory1().create_product() 
  28.     new_product1.show() 
  29.     new_product2 = Factory2().create_product() 
  30.     new_product2.show() 

工厂方法模式优缺点

  • 1.你可以避免创建者和具体产品之间的紧密耦合。
  • 2.单一职责原则。你可以将产品创建代码放在程序的单一位置, 从而使得代码更容易维护。
  • 3.开闭原则。无需更改现有客户端代码, 你就可以在程序中引入新的产品类型。
  • 4.应用工厂方法模式需要引入许多新的子类, 代码可能会因此变得更复杂。最好的情况是将该模式引入创建者类的现有层次结构中。

抽象工厂模式

抽象工厂模式是一种创建型设计模式, 它能创建一系列相关的对象, 而无需指定其具体类。是更多一重的工厂模式中。

 

结构定义(类似工厂模式):

抽象工厂类厂(AbstractFactory):工厂方法模式的核心类,提供创建具体产品的接口,由具体工厂类实现。

具体工厂类(Producer):继承于抽象工厂,实现创建对应具体产品对象的方式。

抽象产品类(Factory):它是具体产品继承的父类(基类)。

具体产品类(Factory1):具体工厂所创建的对象,就是此类。

结构图如下

 

C++实现

  1. #include  
  2. using namespace std; 
  3. class AbstractProductA 
  4. public
  5.     AbstractProductA() {} 
  6.     virtual ~AbstractProductA() {} 
  7.     virtual void Show() = 0; 
  8.     virtual void Disp() = 0; 
  9. }; 
  10.  
  11. class ProductA1 : public AbstractProductA 
  12. private: 
  13.      
  14. public
  15.     ProductA1(){} 
  16.     ~ProductA1(){} 
  17.     void Show() 
  18.     { 
  19.         std::cout<< "productA1 show"<
  20.     } 
  21.     void Disp() 
  22.     { 
  23.         std::cout<< "productA1 Disp"<
  24.     } 
  25. }; 
  26. class ProductA2: public AbstractProductA 
  27. private: 
  28.      
  29. public
  30.     ProductA2(){} 
  31.     ~ProductA2(){} 
  32.     void Show() 
  33.     { 
  34.         std::cout<< "productA2 show"<
  35.     } 
  36.     void Disp() 
  37.     { 
  38.         std::cout<< "productA2 Disp"<
  39.     } 
  40. }; 
  41. class AbstractProductB 
  42. public
  43.     AbstractProductB() {} 
  44.     virtual ~AbstractProductB() {} 
  45.     virtual void Show() = 0; 
  46.     virtual void Disp() = 0; 
  47. }; 
  48.  
  49. class ProductB1 : public AbstractProductB 
  50. public
  51.     void Show() 
  52.     { 
  53.         std::cout<< "productB2 show"<
  54.     } 
  55.     void Disp() 
  56.     { 
  57.         std::cout<< "productB2 Disp"<
  58.     } 
  59. }; 
  60. class Factory 
  61. public
  62.     virtual AbstractProductA *CreateProductA(void) = 0; 
  63.  
  64.     virtual AbstractProductB *CreateProductB(void) = 0; 
  65. }; 
  66. class Factory1 :Factory 
  67. public
  68.     AbstractProductA * CreateProductA(void) 
  69.     { 
  70.         return new ProductA1(); 
  71.     } 
  72.     AbstractProductB * CreateProductB(void) 
  73.     { 
  74.         return new ProductB1(); 
  75.     }  
  76. }; 
  77. class Factory2:Factory 
  78. public
  79.     AbstractProductA * CreateProductA(void) 
  80.     { 
  81.         return new ProductA2(); 
  82.     } 
  83.     AbstractProductB * CreateProductB(void) 
  84.     { 
  85.         return NULL
  86.     }  
  87. }; 
  88.  
  89. int main(int argc, char **argv) 
  90.     Factory2 *new_factory2 = new Factory2(); 
  91.     AbstractProductA *new_productA2 = new_factory2->CreateProductA(); 
  92.     new_productA2->Show(); 
  93.  
  94.     Factory1 *new_factory1 = new Factory1(); 
  95.     AbstractProductB *new_productB1 = new_factory1->CreateProductB(); 
  96.     new_productB1->Show(); 
  97. python 实现 

python 实现

  1. #!/usr/bin/python3 
  2.  
  3.  
  4. class AbstractProductA(object): 
  5.     def show(self): 
  6.         pass 
  7.     def disp(self): 
  8.         pass 
  9.  
  10. class ProductA1(AbstractProductA): 
  11.     def show(self): 
  12.         print("ProductA1 show"
  13.     def disp(self): 
  14.         print("productA1 disp"
  15. class ProductA2(AbstractProductA): 
  16.     def show(self): 
  17.         print("ProductA2 show"
  18.     def disp(self): 
  19.         print("productA2 disp"
  20.  
  21.  
  22. class AbstractProductB(object): 
  23.     def show(self): 
  24.         pass 
  25.  
  26.     def disp(self): 
  27.         pass 
  28. class ProductB1(AbstractProductB): 
  29.     def show(self): 
  30.         print("ProductB1 show"
  31.     def disp(self): 
  32.         print("productB1 disp"
  33.  
  34. class ProductB2(AbstractProductB): 
  35.     def show(self): 
  36.         print("ProductB2 show"
  37.     def disp(self): 
  38.         print("productB2 disp"
  39.  
  40. class Factory(object): 
  41.     def crete_product1(self): 
  42.         pass 
  43.     def crete_product2(self): 
  44.         pass 
  45.  
  46. class FactoryA(object): 
  47.     def crete_product1(self): 
  48.         return ProductA1() 
  49.  
  50.     def crete_product2(self): 
  51.         return ProductA2() 
  52.  
  53. class FactoryB(object): 
  54.     def crete_product1(self): 
  55.         return ProductB1() 
  56.  
  57.     def crete_product2(self): 
  58.         return ProductB2() 
  59.  
  60. if __name__ == "__main__"
  61.     new_factory = FactoryA() 
  62.     new_product1 = new_factory.crete_product1() 
  63.     new_product1.show() 
  64.      
  65.     new_product2 = new_factory.crete_product2() 
  66.     new_product2.disp() 

抽象工厂模式优缺点

  • 1.你可以确保同一工厂生成的产品相互匹配。可以避免客户端和具体产品代码的耦合。
  • 2.单一职责原则。你可以将产品生成代码抽取到同一位置, 使得代码易于维护。
  • 3.开闭原则。向应用程序中引入新产品变体时, 你无需修改客户端代码。
  • 4.由于采用该模式需要向应用中引入众多接口和类, 代码可能会比之前更加复杂。

本文转载自微信公众号「羽林君」,可以通过以下二维码关注。转载本文请联系羽林君公众号。

 

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

设计模式之简单工厂模式、工厂模式、抽象工厂模式的对比

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

设计模式之简单工厂模式、工厂模式、抽象工厂模式的对比

设计模式已经经历了很长一段时间的发展,它们提供了软件开发过程中面临的一般问题的最佳解决方案。学习这些模式有助于经验不足的开发人员通过一种简单快捷的方式来学习软件设计。

简单工厂模式和抽象工厂模式

简单工厂模式,顾名思义,就是比较简单的一个模式,并且使用在业务比较简单的情况下,且具体产品不需要扩张它由三种角色组成工厂类,是这个模式的核心,含有一定的逻辑和判断,根据逻辑不同,产生具体的工厂产品抽象产品:具体产品的父类具体产品:工具抽象产
2023-06-02

Python设计模式之抽象工厂模式

python面向对象编程入门,我们需要不断学习进步 """抽象工厂模式的实现"""import randomclass PetShop:"""宠物商店"""def __init__(self, animal_factory=None):""
2022-06-04

Python实现工厂模式、抽象工厂,单例模式

工厂模式是一种常见的设计模式,它可以帮助我们创建对象的过程更加灵活和可扩展。在Python中,我们可以使用函数和类来实现工厂模式。

设计模式系列-抽象工厂模式

抽象工厂提供了一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。简单来说是为需要创建多个相关联产品的场景提供了解决思路。

设计模式系列—抽象工厂模式

本篇和大家一起来学习抽象工厂模式相关内容。

java设计模式之简单工厂模式详解

简单工厂模式:由一个工厂对象决定创建出哪一种类的实例。1.抽象类public abstract class People { public abstract void doSth();}
2023-05-31

Java简单工厂,工厂方法,抽象工厂模式怎么实现

这篇文章主要讲解了“Java简单工厂,工厂方法,抽象工厂模式怎么实现”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java简单工厂,工厂方法,抽象工厂模式怎么实现”吧!1、简单工厂模式1.定
2023-06-29

编程热搜

  • Python 学习之路 - Python
    一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
    Python 学习之路 - Python
  • chatgpt的中文全称是什么
    chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
    chatgpt的中文全称是什么
  • C/C++中extern函数使用详解
  • C/C++可变参数的使用
    可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
    C/C++可变参数的使用
  • css样式文件该放在哪里
  • php中数组下标必须是连续的吗
  • Python 3 教程
    Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
    Python 3 教程
  • Python pip包管理
    一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
    Python pip包管理
  • ubuntu如何重新编译内核
  • 改善Java代码之慎用java动态编译

目录