[原创][创建型模式] 简单工厂、工厂方法、抽象工厂三种设计模式的理解

企业开发 2018-05-11 23:00:00 阅读次数: 1
简单工厂模式

我的理解：
    假设你需要更换轮胎，你可以选择去一些私人开的小店面；可以去轮胎大卖场；也可以去汽配城。
    假设，你优先选择了小型的店面；由于店面空间有限所有品牌的轮胎都放在唯一的一个柜台里面。这种情况和我们的简单工厂模式很类似。

流程：
    用户代表了客户端的行为，所以逻辑如下：
    (1)用户进入店面，来到柜台前（其实就是SimpleFactory类）；
    (2)通过和柜台人员的沟通选择某一品牌的轮胎（类似SampleFactory中的CreateProduct）,不同品牌的轮胎具有不同的代号；
    (3)选择品牌后，拿出该品牌合适的轮胎（ConcreteProduct），最后提供给客户；


头文件 
//SimapleFactoryPattern.h

#ifndef SIMPLE_FACTORY_PATTERN_H
#define SIMPLE_FACTORY_PATTERN_H

#include <Windows.h>

namespace SimpleFactoryPattern
{
    // Base Class
    //////////////////////////////////////////////////////////////////////////
    class AbstractProduct
    {
    public:
        AbstractProduct();
        virtual ~AbstractProduct();

        virtual void DisplayProductInfo() = 0;
    };


    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductA : public AbstractProduct
    {
    public:
        ConcreteAbstractProductA();
        virtual ~ConcreteAbstractProductA();

        virtual void DisplayProductInfo();
    };

    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductB : public AbstractProduct
    {
    public:
        ConcreteAbstractProductB();
        virtual ~ConcreteAbstractProductB();

        virtual void DisplayProductInfo();
    };

    //////////////////////////////////////////////////////////////////////////
    class SimpleFactory
    {
    public:
        SimpleFactory();
        ~SimpleFactory();

        static AbstractProduct* GetProduct(byte byType)
        {
            AbstractProduct* pTempOp = NULL;

            switch(byType)
            {
            case 0: pTempOp = new ConcreteAbstractProductA(); break;
            case 1: pTempOp = new ConcreteAbstractProductB(); break;
            default: break;
            }
            return pTempOp;
        }
    };


    //////////////////////////////////////////////////////////////////////////
    void SimpleFactoryPattern_Test_0();
    void SimpleFactoryPattern_Test_1();

}

#endif

实现 
#include "SimpleFactoryPattern.h"
#include <iostream>
using namespace std;

namespace SimpleFactoryPattern
{
    //////////////////////////////////////////////////////////////////////////
    AbstractProduct::AbstractProduct()
    {
    }
    AbstractProduct::~AbstractProduct()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteAbstractProductA::ConcreteAbstractProductA()
    {
    }
    ConcreteAbstractProductA::~ConcreteAbstractProductA()
    {
    }
    void ConcreteAbstractProductA::DisplayProductInfo()
    {
        cout << "ConcreteAbstractProductA \n";
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteAbstractProductB::ConcreteAbstractProductB()
    {
    }
    ConcreteAbstractProductB::~ConcreteAbstractProductB()
    {
    }
    void ConcreteAbstractProductB::DisplayProductInfo()
    {
        cout << "ConcreteAbstractProductB \n";
    }

    //////////////////////////////////////////////////////////////////////////
    SimpleFactory::SimpleFactory()
    {
    }
    SimpleFactory::~SimpleFactory()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    void SimpleFactoryPattern_Test_0()
    {
        AbstractProduct* pCurOP = NULL;
        pCurOP = SimpleFactory::GetProduct(0);

        pCurOP->DisplayProductInfo();

        delete pCurOP;
        pCurOP = NULL;
    }

    void SimpleFactoryPattern_Test_1()
    {
        AbstractProduct* pCurOP = NULL;
        pCurOP = SimpleFactory::GetProduct(1);

        pCurOP->DisplayProductInfo();

        delete pCurOP;
        pCurOP = NULL;
    }
}

客户端代码 
#include "SimpleFactoryPattern.h"

#include <iostream>
using namespace std;
using namespace SimpleFactoryPattern;


void main( )
{
    SimpleFactoryPattern_Test_0();
    SimpleFactoryPattern_Test_1();
}

运行结果





工厂方法模式

我的理解：
    假设你需要更换轮胎，你可以选择去一些私人开的小店面；可以去轮胎大卖场；也可以去汽配城。
    假设你的车是豪车，那么前面的小店面肯定是无法满足你的需求，你可以选择一个轮胎大卖场；这时候每一种品牌的轮胎都集中在一个柜台，这样的情况就好像工厂模式一样。一个柜台和多个柜台起本质都是柜台，也可以理解为简单工厂是工厂方法的一个特例。
流程：
    用户代表了客户端的行为，所以逻辑如下：
    (1)用户进入大型的轮胎卖场，并选择一个专卖柜台（每一个柜台其实就是一个ConcreteFactory）；
    (2)通过和柜台人员的沟通选择某一品牌的轮胎（ConcreteProduct）；
    (3)拿出该品牌合适的轮胎，最后提供给客户；



头文件 
//FactoryMethodPattern.h

#ifndef FACTORY_METHOD_PATTERN_H
#define FACTORY_METHOD_PATTERN_H

#include <Windows.h>

namespace FactoryMethodPattern
{
    // Base Class
    //////////////////////////////////////////////////////////////////////////
    class AbstractProduct
    {
    public:
        AbstractProduct();
        virtual ~AbstractProduct();

        virtual void DisplayProductInfo() = 0;
    };


//     //////////////////////////////////////////////////////////////////////////
//     class ConcreteAbstractProductA : public AbstractProduct
//     {
//     public:
//         ConcreteAbstractProductA();
//         virtual ~ConcreteAbstractProductA();
// 
//         virtual void DisplayProductInfo();
//     };
// 
//     //////////////////////////////////////////////////////////////////////////
//     class ConcreteAbstractProductB : public AbstractProduct
//     {
//     public:
//         ConcreteAbstractProductB();
//         virtual ~ConcreteAbstractProductB();
// 
//         virtual void DisplayProductInfo();
//     };


    //////////////////////////////////////////////////////////////////////////
    class AbstractFactory
    {
    public:
        AbstractFactory();
        ~AbstractFactory();

        virtual AbstractProduct* GetProduct() = 0;
    };

//     class ConcreteFactoryA : public AbstractFactory
//     {
//     public:
//         ConcreteFactoryA();
//         virtual ~ConcreteFactoryA();
// 
//         virtual AbstractProduct* GetProduct();
//     };
//     class ConcreteFactoryB: public AbstractFactory
//     {
//     public:
//         ConcreteFactoryB();
//         virtual ~ConcreteFactoryB();
// 
//         virtual AbstractProduct* GetProduct() ;
//     };

    //////////////////////////////////////////////////////////////////////////
    void FactoryMethodPattern_Test_A();
    void FactoryMethodPattern_Test_B();

}

#endif

实现 
#include "FactoryMethodPattern.h"
#include <iostream>
using namespace std;

namespace FactoryMethodPattern
{
    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductA : public AbstractProduct
    {
    public:
        ConcreteAbstractProductA();
        virtual ~ConcreteAbstractProductA();

        virtual void DisplayProductInfo();
    };

    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductB : public AbstractProduct
    {
    public:
        ConcreteAbstractProductB();
        virtual ~ConcreteAbstractProductB();

        virtual void DisplayProductInfo();
    };


    class ConcreteFactoryA : public AbstractFactory
    {
    public:
        ConcreteFactoryA();
        virtual ~ConcreteFactoryA();

        virtual AbstractProduct* GetProduct();
    };
    class ConcreteFactoryB: public AbstractFactory
    {
    public:
        ConcreteFactoryB();
        virtual ~ConcreteFactoryB();

        virtual AbstractProduct* GetProduct() ;
    };



    //////////////////////////////////////////////////////////////////////////
    AbstractProduct::AbstractProduct()
    {
    }
    AbstractProduct::~AbstractProduct()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteAbstractProductA::ConcreteAbstractProductA()
    {
    }
    ConcreteAbstractProductA::~ConcreteAbstractProductA()
    {
    }
    void ConcreteAbstractProductA::DisplayProductInfo()
    {
        cout << "ConcreteAbstractProductA\n";
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteAbstractProductB::ConcreteAbstractProductB()
    {
    }
    ConcreteAbstractProductB::~ConcreteAbstractProductB()
    {
    }
    void ConcreteAbstractProductB::DisplayProductInfo()
    {
        cout << "ConcreteAbstractProductB\n";
    }


    //////////////////////////////////////////////////////////////////////////
    AbstractFactory::AbstractFactory()
    {
    }
    AbstractFactory::~AbstractFactory()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteFactoryA::ConcreteFactoryA()
    {
    }
    ConcreteFactoryA::~ConcreteFactoryA()
    {
    }
    AbstractProduct* ConcreteFactoryA::GetProduct()
    {
        return new ConcreteAbstractProductA();
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteFactoryB::ConcreteFactoryB()
    {
    }
    ConcreteFactoryB::~ConcreteFactoryB()
    {
    }
    AbstractProduct* ConcreteFactoryB::GetProduct()
    {
        return new ConcreteAbstractProductB();
    }

    //////////////////////////////////////////////////////////////////////////
    void FactoryMethodPattern_Test_A()
    {
        AbstractFactory* pCurFactory = new ConcreteFactoryA();
        AbstractProduct* pCurOp = pCurFactory->GetProduct();

        pCurOp->DisplayProductInfo();

        delete pCurOp;
        pCurOp = NULL;

        delete pCurFactory;
        pCurFactory = NULL;
    }

    void FactoryMethodPattern_Test_B()
    {
        AbstractFactory* pCurFactory = new ConcreteFactoryB();
        AbstractProduct* pCurOp = pCurFactory->GetProduct();

        pCurOp->DisplayProductInfo();

        delete pCurOp;
        pCurOp = NULL;

        delete pCurFactory;
        pCurFactory = NULL;
    }
}

客户端代码 
#include "Factory.h"
#include "Product.h"
#include "FactoryMethodPattern.h"

#include <iostream>
using namespace std;
using namespace FactoryMethodPattern;

void main()
{
    FactoryMethodPattern_Test_A();
    FactoryMethodPattern_Test_B();
}

运行结果





抽象工厂模式

我的理解：
    假设你需要更换轮胎，你可以选择去一些私人开的小店面；可以去轮胎大卖场；也可以去汽配城。
    假设你还需要润滑油，你优先选择了汽配城一起购买；不然的话你可能得多跑一趟；那么这个时候你的需求就是两个，这两个需求可以理解为一个产品族，概念图如右：
流程：
    用户代表了客户端的行为，所以逻辑如下：
    (1)用户进入汽配城，选择一个轮胎专卖柜台（每一个柜台其实就是一个ConcreteFactory）；
    (2)通过和柜台人员的沟通选择某一品牌的轮胎（ConcreteProduct）；
    (3)拿出该品牌合适的轮胎，最后提供给客户；
    (4)再选择一个润滑油专卖柜台（每一个柜台其实就是一个ConcreteFactory）；
    (5)通过和柜台人员的沟通选择某一品牌的润滑油（ConcreteProduct）；
    (6)拿出该品牌合适的润滑油，最后提供给客户；




头文件 
//AbstractFactoryPattern.h

#ifndef ABSTRACY_FACTORY_PATTERN_H
#define ABSTRACY_FACTORY_PATTERN_H

#include <Windows.h>
#include <string>
using namespace std;

namespace AbstractFactoryPattern
{
    //////////////////////////////////////////////////////////////////////////
    class AbstractProductA
    {
    public:
        AbstractProductA();
        virtual ~AbstractProductA();

        virtual void DisplayProductAInfo() = 0;
    };


    //     //////////////////////////////////////////////////////////////////////////
    //     class ConcreteAbstractProductA1 : public AbstractProductA
    //     {
    //     public:
    //         ConcreteAbstractProductA1();
    //         virtual ~ConcreteAbstractProductA1();
    // 
    //         virtual void DisplayProductAInfo();
    //     };
    // 
    //     //////////////////////////////////////////////////////////////////////////
    //     class ConcreteAbstractProductA2 : public AbstractProductA
    //     {
    //     public:
    //         ConcreteAbstractProductA2();
    //         virtual ~ConcreteAbstractProductA2();
    // 
    //         virtual void DisplayProductAInfo();
    //     };


    //////////////////////////////////////////////////////////////////////////
    class AbstractProductB
    {
    public:
        AbstractProductB();
        virtual ~AbstractProductB();

        virtual void DisplayProductBInfo() = 0;
    };


    //     //////////////////////////////////////////////////////////////////////////
    //     class ConcreteAbstractProductB1 : public AbstractProductB
    //     {
    //     public:
    //         ConcreteAbstractProductB1();
    //         virtual ~ConcreteAbstractProductB1();
    // 
    //         virtual void DisplayProductBInfo();
    //     };
    // 
    //     //////////////////////////////////////////////////////////////////////////
    //     class ConcreteAbstractProductB2 : public AbstractProductB
    //     {
    //     public:
    //         ConcreteAbstractProductB2();
    //         virtual ~ConcreteAbstractProductB2();
    // 
    //         virtual void DisplayProductBInfo();
    //     };


    //////////////////////////////////////////////////////////////////////////
    class AbstractFactory
    {
    public:
        AbstractFactory();
        ~AbstractFactory();

        virtual AbstractProductA* GetProductA() = 0;
        virtual AbstractProductB* GetProductB() = 0;
    };

    //     class ConcreteFactory1 : public AbstractFactory
    //     {
    //     public:
    //         ConcreteFactory1();
    //         virtual ~ConcreteFactory1();
    // 
    //         virtual AbstractProductA* GetProductA();
    //         virtual AbstractProductB* GetProductB();
    //     };
    //     class ConcreteFactory2: public AbstractFactory
    //     {
    //     public:
    //         ConcreteFactory2();
    //         virtual ~ConcreteFactory2();
    // 
    //         virtual AbstractProductA* GetProductA() ;
    //         virtual AbstractProductB* GetProductB();
    //     };

    //////////////////////////////////////////////////////////////////////////
    void AbstractFactoryPattern_Test_1();
    void AbstractFactoryPattern_Test_2();

}

#endif

实现 
#include "AbstractFactoryPattern.h"
#include <iostream>
using namespace std;

namespace AbstractFactoryPattern
{
    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductA1 : public AbstractProductA
    {
    public:
        ConcreteAbstractProductA1();
        virtual ~ConcreteAbstractProductA1();

        virtual void DisplayProductAInfo();
    };

    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductA2 : public AbstractProductA
    {
    public:
        ConcreteAbstractProductA2();
        virtual ~ConcreteAbstractProductA2();

        virtual void DisplayProductAInfo();
    };


    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductB1 : public AbstractProductB
    {
    public:
        ConcreteAbstractProductB1();
        virtual ~ConcreteAbstractProductB1();

        virtual void DisplayProductBInfo();
    };


    //////////////////////////////////////////////////////////////////////////
    class ConcreteAbstractProductB2 : public AbstractProductB
    {
    public:
        ConcreteAbstractProductB2();
        virtual ~ConcreteAbstractProductB2();

        virtual void DisplayProductBInfo();
    };


    //////////////////////////////////////////////////////////////////////////
    class ConcreteFactory1 : public AbstractFactory
    {
    public:
        ConcreteFactory1();
        virtual ~ConcreteFactory1();

        virtual AbstractProductA* GetProductA();
        virtual AbstractProductB* GetProductB();
    };
    class ConcreteFactory2: public AbstractFactory
    {
    public:
        ConcreteFactory2();
        virtual ~ConcreteFactory2();

        virtual AbstractProductA* GetProductA() ;
        virtual AbstractProductB* GetProductB();
    };

    //////////////////////////////////////////////////////////////////////////
    AbstractProductA::AbstractProductA()
    {
    }
    AbstractProductA::~AbstractProductA()
    {
    }

    ConcreteAbstractProductA1::ConcreteAbstractProductA1()
    {
    }
    ConcreteAbstractProductA1::~ConcreteAbstractProductA1()
    {
    }
    void ConcreteAbstractProductA1::DisplayProductAInfo()
    {
        cout << "ConcreteAbstractProductA1\n";
    }

    ConcreteAbstractProductA2::ConcreteAbstractProductA2()
    {
    }
    ConcreteAbstractProductA2::~ConcreteAbstractProductA2()
    {
    }
    void ConcreteAbstractProductA2::DisplayProductAInfo()
    {
        cout << "ConcreteAbstractProductA2\n";
    }

    //////////////////////////////////////////////////////////////////////////
    AbstractProductB::AbstractProductB()
    {
    }
    AbstractProductB::~AbstractProductB()
    {
    }

    ConcreteAbstractProductB1::ConcreteAbstractProductB1()
    {
    }
    ConcreteAbstractProductB1::~ConcreteAbstractProductB1()
    {
    }
    void ConcreteAbstractProductB1::DisplayProductBInfo()
    {
        cout << "ConcreteAbstractProductB1\n";
    }

    ConcreteAbstractProductB2::ConcreteAbstractProductB2()
    {
    }
    ConcreteAbstractProductB2::~ConcreteAbstractProductB2()
    {
    }
    void ConcreteAbstractProductB2::DisplayProductBInfo()
    {
        cout << "ConcreteAbstractProductB2\n";
    }


    //////////////////////////////////////////////////////////////////////////
    AbstractFactory::AbstractFactory()
    {
    }
    AbstractFactory::~AbstractFactory()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteFactory1::ConcreteFactory1()
    {
    }
    ConcreteFactory1::~ConcreteFactory1()
    {
    }
    AbstractProductA* ConcreteFactory1::GetProductA()
    {
        return new ConcreteAbstractProductA1();
    }
    AbstractProductB* ConcreteFactory1::GetProductB()
    {
        return new ConcreteAbstractProductB1();
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteFactory2::ConcreteFactory2()
    {
    }
    ConcreteFactory2::~ConcreteFactory2()
    {
    }
    AbstractProductA* ConcreteFactory2::GetProductA()
    {
        return new ConcreteAbstractProductA2();
    }
    AbstractProductB* ConcreteFactory2::GetProductB()
    {
        return new ConcreteAbstractProductB2();
    }

    //////////////////////////////////////////////////////////////////////////
    void AbstractFactoryPattern_Test_1()
    {
        AbstractFactory* pCurFactory = new ConcreteFactory1();
        AbstractProductA* pCurProfuctA = pCurFactory->GetProductA();
        AbstractProductB* pCurProfuctB = pCurFactory->GetProductB();

        pCurProfuctA->DisplayProductAInfo();
        pCurProfuctB->DisplayProductBInfo();

        delete pCurProfuctB;
        pCurProfuctB = NULL;

        delete pCurProfuctA;
        pCurProfuctA = NULL;

        delete pCurFactory;
        pCurFactory = NULL;
    }

    void AbstractFactoryPattern_Test_2()
    {
        AbstractFactory* pCurFactory = new ConcreteFactory2();
        AbstractProductA* pCurProfuctA = pCurFactory->GetProductA();
        AbstractProductB* pCurProfuctB = pCurFactory->GetProductB();

        pCurProfuctA->DisplayProductAInfo();
        pCurProfuctB->DisplayProductBInfo();

        delete pCurProfuctB;
        pCurProfuctB = NULL;

        delete pCurProfuctA;
        pCurProfuctA = NULL;

        delete pCurFactory;
        pCurFactory = NULL;
    }
}

客户端代码 
#include "SimpleFactoryPattern.h"

#include <iostream>
using namespace std;
using namespace AbstractFactoryPattern;

void main()
{
    AbstractFactoryPattern_Test_1();
    AbstractFactoryPattern_Test_2();
}

运行结果

猜你喜欢

转载自jacky-dai.iteye.com/blog/2296369
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022