设计模式2——创建型模式之工厂方法模式

 

定义：工厂方法模式(FactoryMethod Pattern)，定义一个用于创建对象的接口，让子类决定实例化哪一个类。定义一个抽象工厂类，每一个产品，按照抽象工厂的基本要求新建一个工厂来生产新的产品。

类型：创建型模式。

类图：

参与角色：

1. AbstrctProduct，提供产品生产的标准接口。
2. ConcreteProductA，ConcreteProductB，按接口具体去实现生产的产品。
3. AbstractFactory，提供标准工厂规模的抽象工厂。
4. ConcreteFactoryA，ConcreteFactoryB，按接口标准定制的具体生产产品的在厂。

概述：

         简单工厂模式，在使用时，会违背OCP原则。工厂方法模式就是为了解决这一问题而产生的。每当有一个新的产品要生产时，不用去更改原有的产品线，也不用去修改原有的工厂，一切按规定析添加。这样产品的生产流程一致，新工厂的建造也一致。工厂原有的生产管理方法便可以继续使用，而且人员也不用重新培训，就可以直接上岗。

         因为当增加新的订单时，不需要去更改旧有的产品线以及工厂，这样就可以最大限度的保证原有的产品能够正常运行。这一点，就是工厂方法的核心。下面就以代码来展现这一过程。

代码：

// C++

#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:

    virtual CCellPhone* CreatePhone() = 0;

};

 

class CNokiaFactory : public CPhoneFactory

{

public:

    virtual CCellPhone* CreatePhone()

    {

        CCellPhone *pPhone = new CNokia();

 

        return pPhone;

    }

};

 

class CSamsungFactory : public CPhoneFactory

{

public:

    virtual CCellPhone* CreatePhone()

    {

        CCellPhone *pPhone = new CSamsung();

 

        return pPhone;

    }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

    // Nokia cellphone production line

    CPhoneFactory* pNokiaFactory = new CNokiaFactory();

    CCellPhone* pNokiaPhone = pNokiaFactory->CreatePhone();

    pNokiaPhone->ProducePhone();

 

    // Samsung cellphone production line

    CPhoneFactory* pSamsungFactory = new CSamsungFactory();

    CCellPhone* pSamsungPhone = pSamsungFactory->CreatePhone();

    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 interface IFactory

    {

        CellPhone CreatePhone();

    }

 

    public class NokiaFactory : IFactory

    {

        public CellPhone CreatePhone()

        {

            CellPhone phone = new Nokia();

 

            return phone;

        }

    }

 

    public class SamsungFactory : IFactory

    {

        public CellPhone CreatePhone()

        {

            CellPhone phone = new Samsung();

 

            return phone;

        }

    }

 

    class Program

    {

        static void Main(string[] args)

        {

            IFactory nokiaFactory = new NokiaFactory();

            CellPhone phone = nokiaFactory.CreatePhone();

            phone.ProducePhone();

 

            IFactory samsungFactory = new SamsungFactory();

            phone = samsungFactory.CreatePhone();

            phone.ProducePhone();

        }

    }

}

 

 

package CellPhone;

 

public interface IFactory {

 

    IPhone createPhone();

}

 

package CellPhone;

 

public interface IPhone {

 

    void producePhone();

    

}

 

package CellPhone;

 

public class NokiaFactory implements IFactory {

 

    public IPhone createPhone()

    {

        IPhone phone = new NokiaPhone();

        

        return phone;

    }

}

 

package CellPhone;

 

public class NokiaPhone implements IPhone {

 

    public void producePhone()

    {

        System.out.println("Produce nokia phone.");

    }

}

 

package CellPhone;

 

public class SamsungFactory implements IFactory {

 

    public IPhone createPhone()

    {

        IPhone phone = new SamsungPhone();

        

        return phone;

    }

}

 

package CellPhone;

 

public class SamsungPhone implements IPhone {

 

    public void producePhone()

    {

        System.out.println("Produce samsung phone.");

    }

}

 

/**

 * CellPhone.java

 */

package CellPhone;

 

/**

 * @author feihe027@163.com

 *

 */

 

public class CellPhone {

 

    /**

     * @param args

     */

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        IFactory factory = new NokiaFactory();

        IPhone phone = factory.createPhone();

        phone.producePhone();

        

        factory = new SamsungFactory();

        phone = factory.createPhone();

        phone.producePhone();

    }

 

}

 

 

 

优缺点：

1. 优点，能够最大限度地保证对修改关闭，对扩展开放。新的产品，都是通过新添加代码来完成而不是去修改原有代码来完成。

2. 缺点，每添加一个新产品，就新建一个工厂，稍显有点浪费。如果工厂过多，管理工厂也会成为一件麻烦事。抽象工厂模式正好解决这一问题。

 

参考资料：

1. 《设计模式——可复用面向对象软件基础》

2. 《Java与模式》

3. 《大话设计模式》