设计模式-对象创建

前言

“对象创建”模式:
通过“对象创建” 模式绕开new，来制止对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
典型模式：

• Factory Method 工厂方法
  
• Abstract Factory 抽象工厂
  
• Prototype
  
• Builder
  

1. Factory Method

1.1 模式介绍

动机：在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来制止客户程序和这种“具体对象创建工作”的紧耦合？
   界说一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。
  

——《设计模式》GoF

  1.2 模式代码

1.2.1 问题代码

1. class ISplitter{
2.     public:
3.         virtual void split()=0;
4.         virtual ~ISplitter(){}
5.     };
6.    
7.     class BinarySplitter : public ISplitter{
8.         
9.     };
10.    
11.     class TxtSplitter: public ISplitter{
12.         
13.     };
14.    
15.     class PictureSplitter: public ISplitter{
16.         
17.     };
18.    
19.     class VideoSplitter: public ISplitter{
20.         
21.     };
22.    
23.    
25. class MainForm : public Form
26. {
27.         TextBox* txtFilePath;
28.         TextBox* txtFileNumber;
29.         ProgressBar* progressBar;
31. public:
32.         void Button1_Click(){
35.         
36.                 ISplitter * splitter=
37.             new BinarySplitter();//依赖具体类
38.         
39.         splitter->split();
41.         }
42. };

复制代码

你有一个按钮，点击按钮以后可以对二进制文件、文本文件、图片文件、视频文件举行分割，如果按照上述代码举行编写，其依赖具体类，如果你想增加其他文件格式方法时，得修改button里的方法，这会使得封装性被粉碎
1.2.2 重构代码

1. //抽象类
2. class ISplitter{
3.     public:
4.         virtual void split()=0;
5.         virtual ~ISplitter(){}
6.     };
7.    
8.    
9. //工厂基类
10. class SplitterFactory{
11. public:
12.     virtual ISplitter* CreateSplitter()=0;
13.     virtual ~SplitterFactory(){}
14. };
16. //具体类
17. class BinarySplitter : public ISplitter{
18.     virtual void split()
19.     {}
21. };
23. class TxtSplitter: public ISplitter{
24.     virtual void split()
25.     {}
26. };
28. class PictureSplitter: public ISplitter{
29.     virtual void split()
30.     {}
31. };
33. class VideoSplitter: public ISplitter{
34.     virtual void split()
35.     {}
36. };
38. //具体工厂
39. class BinarySplitterFactory: public SplitterFactory{
40. public:
41.     virtual ISplitter* CreateSplitter(){
42.         return new BinarySplitter();
43.     }
44. };
46. class TxtSplitterFactory: public SplitterFactory{
47. public:
48.     virtual ISplitter* CreateSplitter(){
49.         return new TxtSplitter();
50.     }
51. };
53. class PictureSplitterFactory: public SplitterFactory{
54. public:
55.     virtual ISplitter* CreateSplitter(){
56.         return new PictureSplitter();
57.     }
58. };
60. class VideoSplitterFactory: public SplitterFactory{
61. public:
62.     virtual ISplitter* CreateSplitter(){
63.         return new VideoSplitter();
64.     }
65. };
67. class MainForm : public Form
68. {
69.     SplitterFactory*  factory;//工厂
71. public:
72.    
73.     MainForm(SplitterFactory*  factory){
74.         this->factory=factory;
75.     }
76.    
77.         void Button1_Click(){
79.         
80.                 ISplitter * splitter=
81.             factory->CreateSplitter(); //多态new
82.         
83.         splitter->split();
85.         }
86. };

复制代码

解决方法：设计一个工厂基类，声明一个创建对象的接口，对象底子工厂基类，实现创建对象的方法，即可实现运行时绑定
1.3 模式类图

1.4 要点总结

• Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
  
• Factory Method模式通过面向对象的本领，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
  
• Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。
  

2. Abstract Factory

2.1 模式介绍

动机：在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，每每存在更多系列对象的创建工作。
如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来制止客户程序和这种“多系列具体对象创建工作”的紧耦合？
   提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
  

——《设计模式》GoF

  2.2 模式代码

抽象工厂是工厂方法模式的子集，当要创建的对象之间有关联时才使用抽象工厂
2.2.1 问题代码

假设现在要实现SQL处理的功能
问题代码1：直接将类型硬编码到功能里，如果有多种数据库，比如MySQL、Oracle等等，就会不利于扩展

1. class EmployeeDAO{
2.    
3. public:
4.     vector<EmployeeDO> GetEmployees(){
5.         SqlConnection* connection =
6.             new SqlConnection();
7.         connection->ConnectionString = "...";
9.         SqlCommand* command =
10.             new SqlCommand();
11.         command->CommandText="...";
12.         command->SetConnection(connection);
14.         SqlDataReader* reader = command->ExecuteReader();
15.         while (reader->Read()){
17.         }
19.     }
20. };

复制代码

问题代码2：在问题代码1的底子上，使用工厂方法解决依赖具体类问题

2. //数据库访问有关的基类
3. class IDBConnection{
4.    
5. };
6. class IDBConnectionFactory{
7. public:
8.     virtual IDBConnection* CreateDBConnection()=0;
9. };
12. class IDBCommand{
13.    
14. };
15. class IDBCommandFactory{
16. public:
17.     virtual IDBCommand* CreateDBCommand()=0;
18. };
21. class IDataReader{
22.    
23. };
24. class IDataReaderFactory{
25. public:
26.     virtual IDataReader* CreateDataReader()=0;
27. };
30. //支持SQL Server
31. class SqlConnection: public IDBConnection{
32.    
33. };
34. class SqlConnectionFactory:public IDBConnectionFactory{
35.    
36. };
39. class SqlCommand: public IDBCommand{
40.    
41. };
42. class SqlCommandFactory:public IDBCommandFactory{
43.    
44. };
47. class SqlDataReader: public IDataReader{
48.    
49. };
50. class SqlDataReaderFactory:public IDataReaderFactory{
51.    
52. };
54. //支持Oracle
55. class OracleConnection: public IDBConnection{
56.    
57. };
59. class OracleCommand: public IDBCommand{
60.    
61. };
63. class OracleDataReader: public IDataReader{
64.    
65. };
69. class EmployeeDAO{
70.     IDBConnectionFactory* dbConnectionFactory;
71.     IDBCommandFactory* dbCommandFactory;
72.     IDataReaderFactory* dataReaderFactory;
73.    
74.    
75. public:
76.     vector<EmployeeDO> GetEmployees(){
77.         IDBConnection* connection =
78.             dbConnectionFactory->CreateDBConnection();
79.         connection->ConnectionString("...");
81.         IDBCommand* command =
82.             dbCommandFactory->CreateDBCommand();
83.         command->CommandText("...");
84.         command->SetConnection(connection); //关联性
86.         IDBDataReader* reader = command->ExecuteReader(); //关联性
87.         while (reader->Read()){
89.         }
91.     }
92. };

复制代码

如果转达的dbConnectionFactory、dbCommandFactory、dataReaderFactory不是同一系列的就会出问题，比方一部分是MySQL对象，一部分是Oracle对象
2.2.2 重构代码

2. //数据库访问有关的基类
3. class IDBConnection{
4.    
5. };
7. class IDBCommand{
8.    
9. };
11. class IDataReader{
12.    
13. };
16. class IDBFactory{
17. public:
18.     virtual IDBConnection* CreateDBConnection()=0;
19.     virtual IDBCommand* CreateDBCommand()=0;
20.     virtual IDataReader* CreateDataReader()=0;
21.    
22. };
25. //支持SQL Server
26. class SqlConnection: public IDBConnection{
27.    
28. };
29. class SqlCommand: public IDBCommand{
30.    
31. };
32. class SqlDataReader: public IDataReader{
33.    
34. };
37. class SqlDBFactory:public IDBFactory{
38. public:
39.     virtual IDBConnection* CreateDBConnection()=0;
40.     virtual IDBCommand* CreateDBCommand()=0;
41.     virtual IDataReader* CreateDataReader()=0;
43. };
45. //支持Oracle
46. class OracleConnection: public IDBConnection{
47.    
48. };
50. class OracleCommand: public IDBCommand{
51.    
52. };
54. class OracleDataReader: public IDataReader{
55.    
56. };
60. class EmployeeDAO{
61.     IDBFactory* dbFactory;
62.    
63. public:
64.     vector<EmployeeDO> GetEmployees(){
65.         IDBConnection* connection =
66.             dbFactory->CreateDBConnection();
67.         connection->ConnectionString("...");
69.         IDBCommand* command =
70.             dbFactory->CreateDBCommand();
71.         command->CommandText("...");
72.         command->SetConnection(connection); //关联性
74.         IDBDataReader* reader = command->ExecuteReader(); //关联性
75.         while (reader->Read()){
77.         }
79.     }
80. };

复制代码

将一系列方法封装在一起，这便是抽象工厂模式
2.3 模式类图

2.4 要点总结

• 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简朴的工厂完全可以。
  
• “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
  
• Abstract Factory模式重要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。
  

3. Prototype

3.1 模式介绍

原型是一种创建型设计模式，它允许您复制现有对象，而不使您的代码依赖于它们的类。
问题：
假设你有一个对象，你想创建它的一个精确副本。你会怎么做？首先，你必须创建一个相同类的新对象。然后你必须遍历原始对象的所有字段并将其值复制到新对象。
很好！但是有一个问题。并非所有对象都可以通过这种方式复制，由于某些对象的字段可能是私有的，从对象自己外部不可见。

直接方法还有一个问题。由于您必须知道对象的类才能创建副本，因此您的代码将依赖于该类。如果额外的依赖关系不吓到您，那么还有另一个问题。偶然您只知道对象遵循的接口，但不知道其具体类，比方，当方法中的参数接受遵循某个接口的任何对象时。
3.2 模式代码

2. //抽象类
3. class ISplitter{
4. public:
5.     virtual void split()=0;
6.     virtual ISplitter* clone()=0; //通过克隆自己来创建对象
7.    
8.     virtual ~ISplitter(){}
10. };
11.    
12.    
13.    
14.    
16. //具体类
17. class BinarySplitter : public ISplitter{
18. public:
19.     virtual ISplitter* clone(){
20.         return new BinarySplitter(*this);
21.     }
22.     virtual void split()
23.     {}
24. };
25.    
26. class TxtSplitter: public ISplitter{
27. public:
28.     virtual ISplitter* clone(){
29.         return new TxtSplitter(*this);
30.     }
31.     virtual void split()
32.     {}
33. };
35. class PictureSplitter: public ISplitter{
36. public:
37.     virtual ISplitter* clone(){
38.         return new PictureSplitter(*this);
39.     }
40.     virtual void split()
41.     {}
42. };
44. class VideoSplitter: public ISplitter{
45. public:
46.     virtual ISplitter* clone(){
47.         return new VideoSplitter(*this);
48.     }
49.     virtual void split()
50.     {}
51. };
53.    
54.    
56. class MainForm : public Form
57. {
58.     ISplitter*  prototype;//原型对象
60. public:
61.    
62.     MainForm(ISplitter*  prototype){
63.         this->prototype=prototype;
64.     }
65.    
66.         void Button1_Click(){
68.                 ISplitter * splitter=
69.             prototype->clone(); //克隆原型
70.         
71.         splitter->split();
73.         }
74. };

复制代码

3.3 模式类图

3.4 要点总结

• 您可以克隆对象而不与其具体类耦合。
  
• 您可以摆脱重复的初始化代码，转而克隆预先构建的原型。
  
• 您可以更加方便地制作复杂的物体。
  
• 处理复杂对象的设置预设时，您可以得到继承的替换方法。
  

4. Builder

4.1 模式介绍

动机：在软件系统中，偶然候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？
   将一个复杂对象的构建与其表示相分离，使得同样的构建过程(稳定)可以创建不同的表示(变化)。
  

——《设计模式》GoF

  4.2 模式代码

1. class House{
2.     //....
3. };
5. class HouseBuilder {
6. public:
7.     House* GetResult(){
8.         return pHouse;
9.     }
10.     virtual ~HouseBuilder(){}
11. protected:
12.    
13.     House* pHouse;
14.         virtual void BuildPart1()=0;
15.     virtual void BuildPart2()=0;
16.     virtual void BuildPart3()=0;
17.     virtual void BuildPart4()=0;
18.     virtual void BuildPart5()=0;
19.        
20. };
22. class StoneHouse: public House{
23.    
24. };
26. class StoneHouseBuilder: public HouseBuilder{
27. protected:
28.    
29.     virtual void BuildPart1(){
30.         //pHouse->Part1 = ...;
31.     }
32.     virtual void BuildPart2(){
33.         
34.     }
35.     virtual void BuildPart3(){
36.         
37.     }
38.     virtual void BuildPart4(){
39.         
40.     }
41.     virtual void BuildPart5(){
42.         
43.     }
44.    
45. };
48. class HouseDirector{
49.    
50. public:
51.     HouseBuilder* pHouseBuilder;
52.    
53.     HouseDirector(HouseBuilder* pHouseBuilder){
54.         this->pHouseBuilder=pHouseBuilder;
55.     }
56.    
57.     House* Construct(){
58.         
59.         pHouseBuilder->BuildPart1();
60.         
61.         for (int i = 0; i < 4; i++){
62.             pHouseBuilder->BuildPart2();
63.         }
64.         
65.         bool flag=pHouseBuilder->BuildPart3();
66.         
67.         if(flag){
68.             pHouseBuilder->BuildPart4();
69.         }
70.         
71.         pHouseBuilder->BuildPart5();
72.         
73.         return pHouseBuilder->GetResult();
74.     }
75. };

复制代码

构建器HouseBuilder负责界说构建House时每个步调的具体接口（变化）和管理正在构建的对象，由子类继承并实现接口；
HouseDirector负责实现House在构建时的整体流程(不变）
4.3 模式类图

4.4 要点总结

• Builder 模式重要用于“分步调构建一个复杂的对象”。在这其中“分步调”是一个稳定的算法，而复杂对象的各个部分则经常变化。
  
• 变化点在哪里，封装哪里—— Builder模式重要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步调构建算法”的需求变动。
  
• 在Builder模式中，要注意不同语言中构造器内调用虚函数的差异（C++ vs. C#) 。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。