設計模式-建立型-工廠模式
阿新 • • 發佈：2019-09-13
工廠設計模式：
顧名思義，該模式是用來生產物件的。在面向物件的設計模式中，萬物皆物件，若使用new來建立物件，就會對該物件產生強耦合，加入我們需要更換該物件，那麼使用該物件的物件都需要進行修改，這顯然違背了開閉原則（OCP）。如果我們使用工廠來產生物件，我們只需要與這個工廠打交道就可以了，無需關心具體的物件，達到解耦的目的。
接下來我們從實際的案例出發，從無工廠到有工廠的區別。
去披薩店訂購披薩，首先披薩的種類很多(CheesePizza、GreekPizza、DurianPizza{等)，披薩的製作流程有prepare、bake、cut、box。
傳統模式：
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 new OrderPizza();
6 }
7 }
8
9 internal class OrderPizza
10 {
11 public OrderPizza()
12 {
13 Pizza pizza = null;
14 string orderType = "";
15 do
16 {
17 orderType = Console.ReadLine();
18 if (orderType == "cheese")
19 {
20 pizza = new CheesePizza();
21 pizza.setName("芝士披薩");
22 }
23 else if (orderType == "greek")
24 {
25 pizza = new GreekPizza();
26 pizza.setName("希臘披薩");
27 }
28 else
29 {
30 Console.WriteLine("訂購失敗");
31 break;
32 }
33 //開始製作
34 pizza.prepare();
35 pizza.bake();
36 pizza.cut();
37 pizza.box();
38 } while (true);
39 }
40 }
41
42 internal abstract class Pizza
43 {
44 private string name;
45
46 public abstract void prepare();
47
48 public void bake()
49 {
50 Console.WriteLine($"{this.name} 烘培");
51 }
52
53 public void cut()
54 {
55 Console.WriteLine($"{this.name} 修剪");
56 }
57
58 public void box()
59 {
60 Console.WriteLine($"{this.name} 打包");
61 }
62
63 public void setName(string name)
64 {
65 this.name = name;
66 }
67 }
68
69 internal class CheesePizza : Pizza
70 {
71 public override void prepare()
72 {
73 Console.WriteLine("芝士披薩準備中");
74 }
75 }
76
77 internal class GreekPizza : Pizza
78 {
79 public override void prepare()
80 {
81 Console.WriteLine("希臘披薩準備中");
82 }
83 }傳統模式的優缺點：
1、比較好理解，易於操作
2、違反OCP原則，即對擴充套件開放，對修改關閉。
3、這裡只訂購了兩種pizza，若現在又新增了品種DurianPizza，這個時候就需要新增該類以及修改OrderPizza中的程式碼。從上圖中可以看出，OrderPizza依賴抽象類及具體實現類的，那怎樣才能切斷OrderPizza與類之間的依賴關係呢。於是我們想到，可以定義一個工廠，訂購者不需要知道具體pizza的製作流程，只要直到我需要訂購什麼型別的pizza就行了。
簡單工廠模式：
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 new OrderPizza();
6 }
7 }
8
9 internal class OrderPizza
10 {
11 public OrderPizza()
12 {
13 Pizza pizza = null;
14 string orderType = "";
15 do
16 {
17 Console.Write("請輸入訂購型別：");
18 orderType = Console.ReadLine();
19 pizza = SimpleFactory.createPizza(orderType);
20 if (pizza == null)
21 {
22 Console.WriteLine("訂購失敗");
23 break;
24 }
25 //開始製作
26 pizza.prepare();
27 pizza.bake();
28 pizza.cut();
29 pizza.box();
30 } while (true);
31 }
32 }
33
34 internal static class SimpleFactory
35 {
36 public static Pizza createPizza(string orderType)
37 {
38 Pizza pizza = null;
39 do
40 {
41 if (orderType == "cheese")
42 {
43 pizza = new CheesePizza();
44 pizza.setName("芝士披薩");
45 }
46 else if (orderType == "greek")
47 {
48 pizza = new GreekPizza();
49 pizza.setName("希臘披薩");
50 }
51 else if (orderType == "durian")
52 {
53 pizza = new DurianPizza();
54 pizza.setName("榴蓮披薩");
55 }
56 return pizza;
57 } while (true);
58 }
59 }
60
61 internal abstract class Pizza
62 {
63 private string name;
64
65 public abstract void prepare();
66
67 public void bake()
68 {
69 Console.WriteLine($"{this.name} 烘培");
70 }
71
72 public void cut()
73 {
74 Console.WriteLine($"{this.name} 修剪");
75 }
76
77 public void box()
78 {
79 Console.WriteLine($"{this.name} 打包");
80 }
81
82 public void setName(string name)
83 {
84 this.name = name;
85 }
86 }
87
88 internal class CheesePizza : Pizza
89 {
90 public override void prepare()
91 {
92 Console.WriteLine("芝士披薩準備中");
93 }
94 }
95
96 internal class GreekPizza : Pizza
97 {
98 public override void prepare()
99 {
100 Console.WriteLine("希臘披薩準備中");
101 }
102 }
103
104 internal class DurianPizza : Pizza
105 {
106 public override void prepare()
107 {
108 Console.WriteLine("榴蓮披薩準備中");
109 }
110 }簡單工廠模式優缺點：
1、由程式碼可以看出，雖然簡單工廠模式一定程度上減少了因需求變更而導致的程式碼更改，但是實際仍違背了OCP原則。
2、所以簡單工廠模式只適合產品物件相對較少，且產品固定的需求，對產品變化無常的需求來說顯然不適合。
工廠方法設計模式：
披薩專案需求變更，客戶點披薩時可以點不同口味的披薩。
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 new BJOrderPizza();
6 }
7 }
8
9 internal abstract class OrderPizza
10 {
11 public OrderPizza()
12 {
13 Pizza pizza = null;
14 string orderType = "";
15 do
16 {
17 Console.Write("請輸入訂購型別：");
18 orderType = Console.ReadLine();
19 pizza = createPizza(orderType);
20 if (pizza == null)
21 {
22 Console.WriteLine("訂購失敗");
23 break;
24 }
25 //開始製作
26 pizza.prepare();
27 pizza.bake();
28 pizza.cut();
29 pizza.box();
30 } while (true);
31 }
32
33 public abstract Pizza createPizza(string orderType);
34 }
35
36 internal class BJOrderPizza : OrderPizza
37 {
38 public override Pizza createPizza(string orderType)
39 {
40 Pizza pizza = null;
41 if (orderType == "cheese")
42 {
43 pizza = new BJCheesePizza();
44 }
45 else if (orderType == "greek")
46 {
47 pizza = new BJGreekPizza();
48 }
49 return pizza;
50 }
51 }
52
53 internal class LDOrderPizza : OrderPizza
54 {
55 public override Pizza createPizza(string orderType)
56 {
57 Pizza pizza = null;
58 if (orderType == "cheese")
59 {
60 pizza = new LDCheesePizza();
61 }
62 else if (orderType == "greek")
63 {
64 pizza = new LDGreekPizza();
65 }
66 return pizza;
67 }
68 }
69
70 internal abstract class Pizza
71 {
72 private string name;
73
74 public abstract void prepare();
75
76 public void bake()
77 {
78 Console.WriteLine($"{this.name} 烘培");
79 }
80
81 public void cut()
82 {
83 Console.WriteLine($"{this.name} 修剪");
84 }
85
86 public void box()
87 {
88 Console.WriteLine($"{this.name} 打包");
89 }
90
91 public void setName(string name)
92 {
93 this.name = name;
94 }
95 }
96
97 internal class BJCheesePizza : Pizza
98 {
99 public override void prepare()
100 {
101 Console.WriteLine("北京的芝士披薩準備中");
102 }
103 }
104
105 internal class BJGreekPizza : Pizza
106 {
107 public override void prepare()
108 {
109 Console.WriteLine("北京的希臘披薩準備中");
110 }
111 }
112
113 internal class LDCheesePizza : Pizza
114 {
115 public override void prepare()
116 {
117 Console.WriteLine("倫敦的芝士披薩準備中");
118 }
119 }
120
121 internal class LDGreekPizza : Pizza
122 {
123 public override void prepare()
124 {
125 Console.WriteLine("倫敦的希臘披薩準備中");
126 }
127 }
view code
工廠方法模式的優缺點：
1、讓父類的實現延遲到子類中去，減少判斷。
2、換湯不換藥，和抽象方法類似，一般適用於產品物件相對較少，且產品固定的需求。
3、工廠方法一定程度上減輕了工廠的職責，將職責細化，避免工廠類無法正常執行而導致程式崩潰。
參考：https://www.jianshu.com/p/38493eb4ffbd&n