当前位置：主页 > 查看内容

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

发布时间：2021-05-06 00:00| 有 位朋友查看

简介：前言： 设计模式已经经历了很长一段时间的发展，它们提供了软件开发过程中面临的一般问题的最佳解决方案。学习这些模式有助于经验不足的开发人员通过一种简单快捷的方式来学习软件设计。 一般我们会说设计模式一共有23种，总体来说设计模式分为三大类： 创建……

 

前言：

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

一般我们会说设计模式一共有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 <iostream> 
  2. using namespace std; 
  3.  
  4. enum Product_Type 
  5. { 
  6.     Product1_, 
  7.     Product2_, 
  8. }; 
  9. class AbstractProduct //抽象（Product）产品角色 
  10. { 
  11. public: 
  12.     AbstractProduct() {} 
  13.     virtual ~AbstractProduct() {} 
  14.     virtual void Show() = 0; 
  15. }; 
  16.  
  17. class Product1 : public AbstractProduct //具体产品（Concrete Product）角色 
  18. { 
  19. private: 
  20.     /* data */ 
  21. public: 
  22.     Product1(/* args */); 
  23.     ~Product1(); 
  24.     void Show() 
  25.     { 
  26.         std::cout<< "product1"<<std::endl; 
  27.     } 
  28. }; 
  29.  
  30. Product1::Product1() 
  31. { 
  32. } 
  33.  
  34. Product1::~Product1() 
  35. { 
  36. } 
  37. class Product2 : public AbstractProduct //具体产品（Concrete Product）角色 
  38. { 
  39. private: 
  40.     /* data */ 
  41. public: 
  42.     void Show() 
  43.     { 
  44.         std::cout<< "product2"<<std::endl; 
  45.     } 
  46. }; 
  47. class Factory  //工厂角色（Creator） 
  48. { 
  49. public: 
  50.     AbstractProduct *CreateProduct(Product_Type  type)  
  51.     { 
  52.         switch (type) 
  53.         { 
  54.         case Product1_/* constant-expression */: 
  55.             /* code */ 
  56.             return new Product1(); 
  57.         case Product2_: 
  58.             return new Product2(); 
  59.         default: 
  60.             return NULL; 
  61.         } 
  62.     } 
  63. }; 
  64. int main(int argc, char **argv) 
  65. { 
  66.     Factory *new_factory = new Factory(); 
  67.     AbstractProduct *new_product1 = new_factory->CreateProduct(Product1_); 
  68.     new_product1->Show(); 
  69.  
  70.  
  71.     AbstractProduct *new_product2 = new_factory->CreateProduct(Product2_); 
  72.     new_product2->Show(); 
  73.      
  74.     delete new_factory,new_product1,new_product2; 
  75.     new_factory = NULL;     
  76.     new_product1 = NULL;     
  77.     new_product2 = NULL;     
  78. } 

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(开闭原则)：一个软件的实体应当对扩展开放，对修改关闭)。

总结 :

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

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

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

工厂模式

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

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

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

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

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

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

C++实现

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

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 <iostream> 
  2. using namespace std; 
  3. class AbstractProductA 
  4. { 
  5. public: 
  6.     AbstractProductA() {} 
  7.     virtual ~AbstractProductA() {} 
  8.     virtual void Show() = 0; 
  9.     virtual void Disp() = 0; 
  10. }; 
  11.  
  12. class ProductA1 : public AbstractProductA 
  13. { 
  14. private: 
  15.     /* data */ 
  16. public: 
  17.     ProductA1(){} 
  18.     ~ProductA1(){} 
  19.     void Show() 
  20.     { 
  21.         std::cout<< "productA1 show"<<std::endl; 
  22.     } 
  23.     void Disp() 
  24.     { 
  25.         std::cout<< "productA1 Disp"<<std::endl; 
  26.     } 
  27. }; 
  28. class ProductA2: public AbstractProductA 
  29. { 
  30. private: 
  31.     /* data */ 
  32. public: 
  33.     ProductA2(){} 
  34.     ~ProductA2(){} 
  35.     void Show() 
  36.     { 
  37.         std::cout<< "productA2 show"<<std::endl; 
  38.     } 
  39.     void Disp() 
  40.     { 
  41.         std::cout<< "productA2 Disp"<<std::endl; 
  42.     } 
  43. }; 
  44. class AbstractProductB 
  45. { 
  46. public: 
  47.     AbstractProductB() {} 
  48.     virtual ~AbstractProductB() {} 
  49.     virtual void Show() = 0; 
  50.     virtual void Disp() = 0; 
  51. }; 
  52.  
  53. class ProductB1 : public AbstractProductB 
  54. { 
  55. public: 
  56.     void Show() 
  57.     { 
  58.         std::cout<< "productB2 show"<<std::endl; 
  59.     } 
  60.     void Disp() 
  61.     { 
  62.         std::cout<< "productB2 Disp"<<std::endl; 
  63.     } 
  64. }; 
  65. class Factory 
  66. { 
  67. public: 
  68.     virtual AbstractProductA *CreateProductA(void) = 0; 
  69.  
  70.     virtual AbstractProductB *CreateProductB(void) = 0; 
  71. }; 
  72. class Factory1 :Factory 
  73. { 
  74. public: 
  75.     AbstractProductA * CreateProductA(void) 
  76.     { 
  77.         return new ProductA1(); 
  78.     } 
  79.     AbstractProductB * CreateProductB(void) 
  80.     { 
  81.         return new ProductB1(); 
  82.     }  
  83. }; 
  84. class Factory2:Factory 
  85. { 
  86. public: 
  87.     AbstractProductA * CreateProductA(void) 
  88.     { 
  89.         return new ProductA2(); 
  90.     } 
  91.     AbstractProductB * CreateProductB(void) 
  92.     { 
  93.         return NULL; 
  94.     }  
  95. }; 
  96.  
  97. int main(int argc, char **argv) 
  98. { 
  99.     Factory2 *new_factory2 = new Factory2(); 
  100.     AbstractProductA *new_productA2 = new_factory2->CreateProductA(); 
  101.     new_productA2->Show(); 
  102.  
  103.     Factory1 *new_factory1 = new Factory1(); 
  104.     AbstractProductB *new_productB1 = new_factory1->CreateProductB(); 
  105.     new_productB1->Show(); 
  106. } 
  107. 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.由于采用该模式需要向应用中引入众多接口和类， 代码可能会比之前更加复杂。

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


本文转载自网络，原文链接：https://mp.weixin.qq.com/s/ewnxn3xIZNNIX84_kQ2qmg
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！
上一篇：彻底掌握分布式事务2PC、3PC模型 下一篇：没有了

推荐图文

  • 周排行
  • 月排行
  • 总排行

随机推荐