设计模式

Tips : 以下是看完很多作者写得设计模式后的一些个人理解 . 以一个生产汽车的工厂为例 , 来阐述3个工厂设计模式.

语言 : JavaScript

简单工厂模式 （Simple Factory） :

产品类 :

现在有两种车型, 他们都继承Car基类, 两种车具有基类的所有属性和方法.

var Car = cc.Class.extend({    ctor: function(){    },})var A_Car = Car.extend({    ctor: function(){        alert("A型车");    },})var B_Car = Car.extend({    ctor: function(){        alert("B型车");    },})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

工厂类 :

工厂提供方法生产并且返回产品.

var Factory = {    createCar: function(type){        switch (type)        {            case "A":                return new A_Car();                break;            case "B":                return new B_Car();                break;        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

客户类 :

客户类调用工厂类里的创建汽车的方法, 传入类型即可获得对应型号的产品.

var SimpleFactory = cc.Node.extend({    ctor: function(){        this._super();        var car = Factory.createCar("B");  //B型车    },})
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

简单工厂模式的3个主要部分 :

1. 抽象产品 : 例子中的基类(父类)“Car”, 所有具体产品都继承它 , 具有它的属性和方法. 
2. 具体产品 : 例子中的“A_Car”和“B_Car”, 简单工厂模式中创建实例的对象. 
3. 工厂类 : 例子中的“Factory”, 做一些逻辑判断和处理 , 是简单工厂模式中的 核心.

小结 :

简单工厂模式 , 从名字上看就知道这个设计模式很简单 , 它的功能是封装程序里不希望被客户知道的实例化细节 , 将实现过程隐藏起来 ,明确各自的职责和权利 , 有利于整个软件体系结构的优化.

---

工厂方法模式 （Factory Method） :

产品类 :

和简单工厂模式产品类一样 , 两种车型, 继承Car基类, 具有基类的所有属性和方法.

var Car = cc.Class.extend({    ctor: function(){    },})var A_Car = Car.extend({    ctor: function(){        alert("A型车");    },})var B_Car = Car.extend({    ctor: function(){        alert("B型车");    },})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

工厂类 :

与简单工厂模式有所不同 , 工厂模式的 Factory 是一个抽象类 , 里面提供一个抽象方法 , 供给其他具体工厂类继承、实现 , 这样处理的原因是当创建的产品类型需要增加时 , 可以很好的遵循 open & close 设计原则 , 对拓展开放 对修改关闭 .

var Factory = cc.Class.extend({    createCar : function(){    }})var A_CarFactory = Factory.extend({    createCar : function(){        return new A_Car();    }})var B_CarFactory = Factory.extend({    createCar : function(){        return new B_Car();    }})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

客户类 :

var FactoryMethod = cc.Node.extend({    ctor: function(){        this._super();        var factory = new A_CarFactory();        var Acar = factory.createCar();   //A型车    }})
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

工厂方法的4个主要部分 :

1. 抽象产品 : 基类(父类)“Car”, 所有具体产品都继承它 , 具有它的属性和方法.(和简单工厂模式一样) 
2. 具体产品 : “A_Car”和“B_Car”, 创建实例的对象.(和简单工厂模式一样) 
3. 抽象工厂类 : 基类(父类)“Factory”, 它提供抽象方法给具体工厂类 继承 和 实现 , 是工厂方法的 核心. 
4. 具体工厂类 : “A_CarFactory ” 和 ” B_CarFactory “, 继承并实现接口父类的 接口.

小结 :

1. 工厂模式和简单工厂模式最大的区别是 , 工厂模式多了抽象工厂类 , 这样的好处是 , 当有新产品添加的时候(需求变化) , 可以直接扩展一个新的工厂 , 而不是修改原来的工厂类代码 , 这样做是为了遵循 open & close 设计原则 .

2. 在工厂模式中 , 一个具体的工厂类 , 只允许生产一个相对应产品 , 简单的说就是 , 当你选择了一个具体工厂类的时候 , 就选择了具体产品 , 相对于简单工厂，将选择产品的动作提前了.

---

抽象工厂模式 （Abstract Factory） :

假设需求改变 , 例如不同型号的车需要不同型号的电池 , 在生产时 , 给他们配备符合车型号的电池 , 当这样需求出现的时候 , 可以考虑使用抽象工厂模式创建 .

产品类 :

//抽象产品类  车(Car)var Car = cc.Class.extend({    ctor: function(){    }});//具体产品类var A_Car = Car.extend({    ctor: function(){        alert("A型车");    }});var B_Car = Car.extend({    ctor: function(){        alert("B型车");    }});//----------------------------//抽象产品类  电池(Battery)var Battery = cc.Class.extend({    ctor: function(){    }});//具体产品类var A_Battery = Battery.extend({    ctor: function(){        alert("A型电池");    }});var B_Battery = Battery.extend({    ctor: function(){        alert("B型电池");    }});
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
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

工厂类 :

// 抽象工厂类  Factory var Factory = cc.Class.extend({    createCar : function(){    },    createBattery : function(){    }});// 具体工厂类 var A_CarFactory = Factory.extend({    createCar : function(){        return new A_Car();    },    createBattery : function(){        return new A_Battery();    }});var B_CarFactory = Factory.extend({    createCar : function(){        return new B_Car();    },    createBattery : function(){        return new B_Battery();    }});
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
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

客户类 :

var AbstractFactory = cc.Node.extend({    ctor: function(){        this._super();        var factory = new A_CarFactory();        var Acar = factory.createCar();          // A型车        var ABattery = factory.createBattery();  // A型电池    }});
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

工厂方法的4个主要部分 :

1. 抽象产品 : 基类(父类)“Car” 和“Battery” , 对应具体产品继承它 , 具有它的属性和方法. 
2. 具体产品 : “A_Car”、“B_Car”、“A_Battery”、“B_Battery”, 继承抽象类 , 创建实例的对象. 
3. 抽象工厂类 : 基类(父类)“Factory”, 它提供抽象方法给具体工厂类 继承 和 实现 , 是抽象工厂模式的 核心. 
4. 具体工厂类 : “A_CarFactory ” 和 ” B_CarFactory “, 继承并实现接口父类的 接口.

小结 :

1. 想比较起工厂方法 , 抽象工厂模式最大的亮点在于可以创建多个产品 , 并且保留了工厂模式的所有优点. 
2. 对客户创建过程再进行封装一下或者说套用简单工厂模式的具体工厂类 , 可以做到让客户类在不必指定产品具体类型的情况下，创建多个产品族中的产品对象 .

---

总结 :

共同点 :

1. 创建过程类似 , 作用类似 . 
2. 都具有抽象产品类、具体产品类和工厂类 , 其中 具体产品类 继承 抽象产品类 . 
3. 工厂类实例化产品类(new生成产品类的实例化对象) , 并将生成的产品类的对象提供给外部使用 .

不同点 :

简单工厂模式 :

1. 一般只包含一个具体的工厂类 , 没有抽象工厂类 . 
2. 工厂类直接被客户类调用, 可以生成所有产品类的对象 
3. 工厂类内部一般是类似于switch的结构 , 根据传入的标志自己判断、处理, 最后返回产品 .

---

工厂方法 :

1. 一般具有抽象产品类、具体产品类、抽象工厂类 和 具体工厂类 , 其中 具体工厂类 都要继承 抽象工厂类 , 具体工厂类可以存在多个 . 
2. 与简单工厂模式相比 , 具体工厂类 不做逻辑处理 , 只提供方法生成产品 , 一个具体工厂对应一个具体产品 .

---

抽象工厂模式 :

附加 :

工厂方法构成 : 
一个抽象产品类，可以派生出多个具体产品类. 
一个抽象工厂类，可以派生出多个具体工厂类. 
每个具体工厂类只能创建一个具体产品类的实例.

抽象工厂模式构成： 
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类. 
一个抽象工厂类，可以派生出多个具体工厂类. 
每个具体工厂类可以创建多个具体产品类的实例.

1. 
抽象工厂模式中 具有多个 抽象产品类 . 
工厂方法中 只有一个抽象产品类 .

2. 
抽象工厂模式中的 具体工厂类 可以生产多个产品 . 
工厂方法中 只能生产一个 .