定義：簡單工廠模式(Simple Factory Pattern)，有一個提供接口的抽象類，然后實現不同功能的子類去實現抽象類，最后一個簡單工廠類來完成對不同功能子類的創建。
類型：創建型模式。
類圖：
參與角色：
1. 抽象產品，提供接口供Client調用。
1. 具體產品，根據具體產品的要求去實現接口。
1. 工廠類，根據傳入參數的不同，創建不同的產品。
概述：
??????? 簡單工廠模式并不是GoF的23個設計模式之中，因為簡單工廠模式是工廠方法模式的一種特例。但現實中，簡單工廠模式使用得非常廣泛，所以在此單列出予以記錄。
?????? 假設有一手機代工廠，前些年買了兩條手機生產線，全部代工Nokia的手機。但是隨著智能手機的崛起，Nokia手機銷量的大幅下滑，使得一條Nokia手機生產線不得不停工。眼看生產線停工，老板發動人脈，終于拉到了一個新的訂單，代工Samsun手機。因為手機零配件基本一致，裝配流程也一樣，所以Nokia的手機生產線，經過細微更改就可以生產Samsung手機了，而且先前的生產工人基本不需要培訓，立即就可以進入Samsung手機生產線生產了。停工的生產線又一次啟動了。
????? 這一案例正好非常適合簡單工廠模式。標準流程的手機生產線，即是抽象產品類。Nokia，Samsung即是兩個具體的手機生產線產品。然后工廠就根據拿到的訂單，分別代工生產不同的手機。
代碼：
[]( "復制代碼")
~~~
1 #include <iostream>
2 #include <afxcom_.h>
3 using namespace std;
4
5 class CCellPhone
6 {
7 public:
8 virtual void ProducePhone()
9 {
10 cout<<"Produce Normal Phone."<<endl;
11 }
12 };
13
14 class CNokia : public CCellPhone
15 {
16 public:
17 virtual void ProducePhone()
18 {
19 cout<<"Produce Nokia Phone."<<endl;
20 }
21 };
22
23 class CSamsung : public CCellPhone
24 {
25 public:
26 virtual void ProducePhone()
27 {
28 cout<<"Produce Samsung Phone."<<endl;
29 }
30 };
31
32 class CPhoneFactory
33 {
34 public:
35 static CCellPhone* CreatePhone(int _nType)
36 {
37 CCellPhone* pPhone = NULL;
38
39 switch (_nType)
40 {
41 case 0: // Nokia
42 pPhone = new CNokia();
43 break;
44 case 1: // Samsung
45 pPhone = new CSamsung();
46 break;
47 default:
48 ASSERT(FALSE);
49 break;
50 }
51
52 return pPhone;
53 }
54 };
55
56 int _tmain(int argc, _TCHAR* argv[])
57 {
58 // Nokia cellphone production line
59 CCellPhone* pNokiaPhone = CPhoneFactory::CreatePhone(0);
60 pNokiaPhone->ProducePhone();
61
62 // Samsung cellphone production line
63 CCellPhone* pSamsungPhone = CPhoneFactory::CreatePhone(1);
64 pSamsungPhone->ProducePhone();
65
66 delete pNokiaPhone;
67 pNokiaPhone = NULL;
68
69 delete pSamsungPhone;
70 pSamsungPhone = NULL;
71
72 return 0;
73 }
~~~
[]( "復制代碼")
[]( "復制代碼")
~~~
1 // C#代碼
2 using System;
3 using System.Collections.Generic;
4 using System.Text;
5 using System.Diagnostics;
6
7
8 namespace Phone
9 {
10 public class CellPhone
11 {
12 public virtual void ProducePhone()
13 {
14 Console.WriteLine("Produce Normal Phone.");
15 }
16 }
17
18 class Nokia : CellPhone
19 {
20 public override void ProducePhone()
21 {
22 Console.WriteLine("Produce Nokia Phone.");
23 }
24 }
25
26 class Samsung : CellPhone
27 {
28 public override void ProducePhone()
29 {
30 Console.WriteLine("Produce Samsung Phone.");
31 }
32 }
33
34 public class PhoneFactory
35 {
36 public static CellPhone CreatePhone(string _strName)
37 {
38 CellPhone phone = null;
39
40 switch (_strName)
41 {
42 case "Nokia":
43 phone = new Nokia();
44 break;
45 case "Samsung":
46 phone = new Samsung();
47 break;
48 default:
49 Debug.Assert(false);
50 break;
51 }
52
53 return phone;
54 }
55 }
56
57 class Program
58 {
59 static void Main(string[] args)
60 {
61 CellPhone phone = PhoneFactory.CreatePhone("Nokia");
62 phone.ProducePhone();
63
64 phone = PhoneFactory.CreatePhone("Samsung");
65 phone.ProducePhone();
66 }
67 }
68 }
~~~
[]( "復制代碼")
[]( "復制代碼")
~~~
1 /**
2 * CellPhone.java
3 */
4
5 /**
6 * @author feihe027@163.com
7 *
8 */
9 public class CellPhone {
10
11 public static void main(String[] args) {
12 // TODO Auto-generated method stub
13
14 // Nokia cellphone production line
15 ICellPhone nokiaPhone = PhoneFactory.createPhone("Nokia");
16 nokiaPhone.producePhone();
17
18 // Samsung cellphone production line
19 ICellPhone samsungPhone = PhoneFactory.createPhone("Samsung");
20 samsungPhone.producePhone();
21 }
22
23 }
24
25
26 public class PhoneFactory {
27
28 public static ICellPhone createPhone(String _strName) {
29 ICellPhone phone = null;
30 switch (_strName) {
31 case "Nokia":
32 phone = new NokiaPhone();
33 break;
34 case "Samsung":
35 phone = new Samsung();
36 break;
37 default:
38 break;
39 }
40
41 return phone;
42 }
43 }
44
45
46 /**
47 * IEllPhone.java
48 */
49
50 /**
51 * @author feihe027@163.com
52 *
53 */
54
55 public interface ICellPhone {
56
57 // The interface that produce cellphone
58 public void producePhone();
59
60 }
61
62
63 /**
64 * NokiaPhone.java
65 */
66
67 /**
68 * @author feihe027@163.com
69 *
70 */
71
72 public class NokiaPhone implements ICellPhone {
73
74 public void producePhone()
75 {
76 System.out.println("Produce Nokia Phone.");
77 }
78 }
79
80
81 /**
82 * Samsung.java
83 */
84
85 /**
86 * @author feihe027@163.com
87 *
88 */
89 public class Samsung implements ICellPhone{
90
91 public void producePhone() {
92 System.out.println("Produce Samsung Phone.");
93 }
94
95 }
~~~
[]( "復制代碼")
優缺點：
1. 優點，客戶不需要了解產品的具體實現過程，只需要關注生產產品的接口即好。另外客戶只需要告訴工廠需要什么類型的產品，工廠即會提供給客戶指定的產品。非常簡單，所以在不是非常大型的項目的編程當中，經常被用到。
1. 缺點，當工廠老板拉到新顧客LG時，引入新的生產線，但是在確定生產哪種類型的手機時，必須得修改工廠類,這違背了OCP(開閉原則)。工廠方法模式就是為了解決這個問題而產生的。
參考資料：
1. 《java與模式》
1. 《UML基礎、案例與應用》
1. 《大話設計模式》
1. 一些網絡博客
[源代碼下載](http://files.cnblogs.com/feihe0755/CellPhone.rar)
- 前言
- 設計模式六大原則
- 1——創建型模式之簡單工廠模式
- 2——創建型模式之工廠方法模式
- 3——創建型模式之抽象工廠模式
- 4——創建型模式之單例模式
- 5——創建型模式之建造者模式
- 6——創建型模式之原型模式
- 7——結構型模式之適配器模式
- 8——結構型模式之橋接模式
- 9——結構型模式之組合模式
- 10——結構型模式之裝飾者模式
- 11——結構型模式之外觀模式
- 12——結構型模式之享元模式
- 13——結構型模式之代理模式
- 14——行為型模式之職責鏈模式
- 15——行為型模式之命令模式
- 16——行為型模式之解釋器模式
- 17——行為型模式之迭代器模式
- 18——行為型模式之中介者模式
- 19——行為型模式之備忘錄模式
- 20——行為型模式之觀察者模式
- 21——行為型模式之狀態模式
- 22——行為型模式之策略模式
- 23——行為型模式之模板方法模型
- 24——行為型模式之訪問者模式
- 設計模式總結