`

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

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

流程：
    用户代表了客户端的行为，所以逻辑如下：
    (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();
}

运行结果
分享到：
| UML类图几种关系的总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    [浪曦原创]JAVA设计模式 第4讲 抽象工厂(jzkangta)

    学习这个模式时，需要注意理解抽象工厂模式与其他创建型模式（如简单工厂、工厂方法和建造者模式）的区别，以及如何在实际项目中合理选择和应用。同时，也要关注模式的优缺点，例如它能很好地封装变化，但可能会导致...

    [浪曦原创]JAVA设计模式 第2讲 单态模式和简单工厂模式(jzkangta).rar

    Java设计模式是软件开发中的重要概念，它们是解决常见...这个压缩包资料“[浪曦原创]JAVA设计模式 第2讲 单态模式和简单工厂模式(jzkangta)”应包含了详细的讲解和示例代码，可以帮助深入理解和应用这两种设计模式。

    java设计模式_原创

    1. 创建型设计模式：这类模式关注对象的创建过程，它们包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。单例模式确保一个类只有一个实例，并提供全局访问点；工厂方法模式定义一个用于创建对象的...

    原创－设计模式实现代码

    设计模式分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。这些模式都有其独特的应用场景和目标，下面将对每一类模式进行详细介绍。 1. ...

    w3school 设计模式教程 飞龙整理 20141001

    1. 创建型模式：关注对象的创建，比如工厂模式（用于创建对象而不暴露创建逻辑）、抽象工厂模式（提供一个创建一系列相关或相互依赖对象的接口）、单例模式（确保一个类只有一个实例）、建造者模式（将复杂对象的...

    设计模式 c# 代码

    工厂模式是一种创建型设计模式，提供了一种创建对象的最佳方式。在C#中，可以通过定义一个创建对象的接口，让子类决定实例化哪一个类，从而使代码更灵活，易于扩展。 三、抽象工厂模式（Abstract Factory） 抽象...

    大中型电子商务(asp.net,c#)

    6. YXShop.DALFactory、SQLProfileDAL、YXShop.Bll、YXShop.DBUtility、YXShop.DALProfile - 这些是源码的不同部分，分别代表数据访问层（DAL）、业务逻辑层（BLL）、数据库实用工具和数据访问层的工厂模式实现。...

    php类库整理

    2. **自定义类**：描述中提到有一些类库是自己编写的，这可能涉及到面向对象编程中的设计模式，如单例、工厂、观察者等，以及各种实用工具类，如日志记录、缓存管理、数据库操作等。这些自定义类通常遵循一定的命名...

Magicbox
Global site tag (gtag.js) - Google Analytics