设计模式1——创建型模式之简单工厂模式

定义：简单工厂模式(Simple Factory Pattern)，有一个提供接口的抽象类，然后实现不同功能的子类去实现抽象类，最后一个简单工厂类来完成对不同功能子类的创建。

类型：创建型模式。

类图：

 

参与角色：

1. 抽象产品，提供接口供Client调用。
2. 具体产品，根据具体产品的要求去实现接口。
3. 工厂类，根据传入参数的不同，创建不同的产品。

概述：

         简单工厂模式并不是GoF的23个设计模式之中，因为简单工厂模式是工厂方法模式的一种特例。但现实中，简单工厂模式使用得非常广泛，所以在此单列出予以记录。

        假设有一手机代工厂，前些年买了两条手机生产线，全部代工Nokia的手机。但是随着智能手机的崛起，Nokia手机销量的大幅下滑，使得一条Nokia手机生产线不得不停工。眼看生产线停工，老板发动人脉，终于拉到了一个新的订单，代工Samsun手机。因为手机零配件基本一致，装配流程也一样，所以Nokia的手机生产线，经过细微更改就可以生产Samsung手机了，而且先前的生产工人基本不需要培训，立即就可以进入Samsung手机生产线生产了。停工的生产线又一次启动了。

       这一案例正好非常适合简单工厂模式。标准流程的手机生产线，即是抽象产品类。Nokia，Samsung即是两个具体的手机生产线产品。然后工厂就根据拿到的订单，分别代工生产不同的手机。

代码：

#include <iostream>
#include <afxcom_.h> 
using namespace std;

class CCellPhone
{
public:
    virtual void ProducePhone()
    {
        cout<<"Produce Normal Phone."<<endl;
    }
};

class CNokia : public CCellPhone
{
public:
    virtual void ProducePhone()
    {
        cout<<"Produce Nokia Phone."<<endl;
    }
};

class CSamsung : public CCellPhone
{
public:
    virtual void ProducePhone()
    {
        cout<<"Produce Samsung Phone."<<endl;
    }
};

class CPhoneFactory
{
public:
    static CCellPhone* CreatePhone(int _nType)
    {
        CCellPhone* pPhone = NULL;

        switch (_nType)
        {
        case 0: // Nokia
            pPhone = new CNokia();
            break;
        case 1: // Samsung
            pPhone = new CSamsung();
            break;
        default:
            ASSERT(FALSE);
            break;
        }

        return pPhone;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    // Nokia cellphone production line
    CCellPhone* pNokiaPhone = CPhoneFactory::CreatePhone(0);
    pNokiaPhone->ProducePhone();

    // Samsung cellphone production line
    CCellPhone* pSamsungPhone = CPhoneFactory::CreatePhone(1);
    pSamsungPhone->ProducePhone();

    delete pNokiaPhone;
    pNokiaPhone = NULL;

    delete pSamsungPhone;
    pSamsungPhone = NULL;

    return 0;
}

// C#代码
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;


namespace Phone
{
    public class CellPhone
    {
        public virtual void ProducePhone()
        {
            Console.WriteLine("Produce Normal Phone.");
        }
    }

    class Nokia : CellPhone
    {
        public override void ProducePhone()
        {
            Console.WriteLine("Produce Nokia Phone.");
        }
    }

    class Samsung : CellPhone
    {
        public override void ProducePhone()
        {
            Console.WriteLine("Produce Samsung Phone.");
        }
    }

    public class PhoneFactory
    {
        public static CellPhone CreatePhone(string _strName)
        {
            CellPhone phone = null;

            switch (_strName)
            {
                case "Nokia":
                    phone = new Nokia();
                    break;
                case "Samsung":
                    phone = new Samsung();
                    break;
                default:
                    Debug.Assert(false);
                    break;
            }

            return phone;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            CellPhone phone = PhoneFactory.CreatePhone("Nokia");
            phone.ProducePhone();

            phone = PhoneFactory.CreatePhone("Samsung");
            phone.ProducePhone();
        }
    }
}

/**
 * CellPhone.java
 */

/**
 * @author feihe027@163.com
 *
 */
public class CellPhone {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        // Nokia cellphone production line
        ICellPhone nokiaPhone = PhoneFactory.createPhone("Nokia");
        nokiaPhone.producePhone();
        
        // Samsung cellphone production line
        ICellPhone samsungPhone = PhoneFactory.createPhone("Samsung");
        samsungPhone.producePhone();
    }
    
}


public class PhoneFactory {

    public static ICellPhone createPhone(String _strName) {
        ICellPhone phone = null;
        switch (_strName) {
        case "Nokia":
            phone = new NokiaPhone();
            break;
        case "Samsung":
            phone = new Samsung();
            break;
        default:
            break;
        }
        
        return phone;
    }
}


/**
 * IEllPhone.java
 */

/**
 * @author feihe027@163.com
 *
 */

public interface ICellPhone {
    
    // The interface that produce cellphone
    public void producePhone();
    
}


/**
 * NokiaPhone.java
 */

/**
 * @author feihe027@163.com
 *
 */

public class NokiaPhone implements ICellPhone {

    public void producePhone()
    {
        System.out.println("Produce Nokia Phone.");
    }
}


/**
 * Samsung.java
 */

/**
 * @author feihe027@163.com
 *
 */
public class Samsung implements ICellPhone{

    public void producePhone() {
        System.out.println("Produce Samsung Phone.");
    }

}

优缺点：

1. 优点，客户不需要了解产品的具体实现过程，只需要关注生产产品的接口即好。另外客户只需要告诉工厂需要什么类型的产品，工厂即会提供给客户指定的产品。非常简单，所以在不是非常大型的项目的编程当中，经常被用到。
2. 缺点，当工厂老板拉到新顾客LG时，引入新的生产线，但是在确定生产哪种类型的手机时，必须得修改工厂类,这违背了OCP(开闭原则)。工厂方法模式就是为了解决这个问题而产生的。

参考资料：

1. 《java与模式》
2. 《UML基础、案例与应用》

3. 《大话设计模式》

4. 一些网络博客

源代码下载