对象创造模式

对象创造模式概念

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

1、工厂方法模式（Factory Method）

动机 （Motivation)

• 在软件系统中，经常面临着创建对象的工作;由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化?如何绕过常规的对象创建方法(new)，提供一种“封装机制"来避免客户程序和这种“具体对象创建工作”的紧耦合?

模式定义

• 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的:解耦，手段:虚函数)到子类。

代码具体实现

1. 正常实现一波，依赖于具体类，不符合依赖倒置原则

class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

class BinarySplitter : public ISplitter{
public:
    virtual void split() {}
};

class TxtSplitter: public ISplitter{
public:
    virtual void split() {}
};

class PictureSplitter: public ISplitter{
public:
    virtual void split() {}
};

class VideoSplitter: public ISplitter{
public:
    virtual void split() {}
};



class MainForm
{
public:
	void Button1_Click(){
        // 当我们需求进行改变的时候，需要修改这一部分代码
		ISplitter * splitter=
            new BinarySplitter();//依赖具体类
        
        splitter->split();

	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2. 我们现在把他改造成工厂方法模式，不让他依赖于具体类，需要依赖于抽象。把具体的时候集中到外部，保持我MainForm的稳定

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

//具体类
class BinarySplitter : public ISplitter{
public:
    virtual void split() {}
};

class TxtSplitter: public ISplitter{
public:
    virtual void split() {}
};

class PictureSplitter: public ISplitter{
public:
    virtual void split() {}
};

class VideoSplitter: public ISplitter{
public:
    virtual void split() {}
};

/*---------------------------------------*/


//工厂基类
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter()=0;
    virtual ~SplitterFactory(){}
};

//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};

class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

class PictureSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new PictureSplitter();
    }
};

class VideoSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new VideoSplitter();
    }
};


/*------------------------------------------*/

class MainForm
{
    SplitterFactory*  factory;//工厂

public:
    
    MainForm(SplitterFactory*  factory){
        this->factory = factory;
    }
    
	void Button1_Click(){

        // 这里的时候我们创建新的模式的时候主要依赖于抽象
        // 构造器建造一个新的模式对象时候由外部传参进来
		ISplitter * splitter=
            factory->CreateSplitter(); //多态new
        
        splitter->split();

	}
};

/*
我觉得这个代码的实现方法好像也可以,
但是这个每次只能创建一个Splitter实例
工厂模式会每次Button1_Click创建一哥新的Splitter
也就是相当于一个专门的工厂生产一类产品
所以还是的依据具体需求而设计不同的模式

class MainForm
{
    ISplitter*  splitter;//工厂

public:
    
    MainForm(ISplitter*  splitter){
        this->splitter = splitter;
    }
    
	void Button1_Click(){
        splitter->split();
	}
};
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

要点总结

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

2、抽象工厂模式（Abstract Factory）

3、原型模式（Prototype）

4、构建器模式（Builder）