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

最新推荐文章于 2022-05-02 09:49:48 发布
最新推荐文章于 2022-05-02 09:49:48 发布
阅读量170 收藏
点赞数
分类专栏： 设计模式 C++ 文章标签： 设计模式 php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jacky_Dai/article/details/84796579
版权
[color=red][size=large][align=center]简单工厂模式[/align][/size][/color]
[color=green][b][size=medium]我的理解：[/size][/b][/color]
假设你需要更换轮胎，你可以选择去一些私人开的小店面；可以去轮胎大卖场；也可以去汽配城。
假设，你优先选择了小型的店面；由于店面空间有限所有品牌的轮胎都放在唯一的一个柜台里面。这种情况和我们的简单工厂模式很类似。

[color=green][b][size=medium]流程：[/size][/b][/color]
用户代表了客户端的行为，所以逻辑如下：
(1)用户进入店面，来到柜台前（其实就是SimpleFactory类）；
(2)通过和柜台人员的沟通选择某一品牌的轮胎（类似SampleFactory中的CreateProduct）,不同品牌的轮胎具有不同的代号；
(3)选择品牌后，拿出该品牌合适的轮胎（ConcreteProduct），最后提供给客户；
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243079450997&size=800_600&devtype=web&v=1.0.1&rtick=14676158838200&share_qid=108635719&sign=5832b5ba18f39af9028cf6edfb1b8945&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243079453101&size=800_600&devtype=web&v=1.0.1&rtick=14676158837309&share_qid=108635719&sign=0f1d87891df7b5792d2922048ac405d9&[/img]
[color=red][b]头文件[/b][/color] 

//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

[color=red][b]实现[/b][/color] 

#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;
    }
}


[b][color=red]客户端代码[/color][/b] 

#include "SimpleFactoryPattern.h"

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


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

[color=red][b]运行结果[/b][/color]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661259749438502&size=800_600&devtype=web&v=1.0.1&rtick=14661259839407&share_qid=108635719&sign=d6c0e09e108e108b3d01aad0d1139c09&[/img]


[color=red][size=large][align=center]工厂方法模式[/align][/size][/color]
[b][color=olive][size=medium]我的理解：[/size][/color][/b]
假设你需要更换轮胎，你可以选择去一些私人开的小店面；可以去轮胎大卖场；也可以去汽配城。
假设你的车是豪车，那么前面的小店面肯定是无法满足你的需求，你可以选择一个轮胎大卖场；这时候每一种品牌的轮胎都集中在一个柜台，这样的情况就好像工厂模式一样。一个柜台和多个柜台起本质都是柜台，也可以理解为简单工厂是工厂方法的一个特例。
[b][color=green][size=medium]流程：[/size][/color][/b]
用户代表了客户端的行为，所以逻辑如下：
(1)用户进入大型的轮胎卖场，并选择一个专卖柜台（每一个柜台其实就是一个ConcreteFactory）；
(2)通过和柜台人员的沟通选择某一品牌的轮胎（ConcreteProduct）；
(3)拿出该品牌合适的轮胎，最后提供给客户；
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=13770720602900167&size=800_600&devtype=web&v=1.0.1&rtick=14661259823351&share_qid=108635719&sign=dba95a905666f795c8887004664a7de8&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243069446399&size=800_600&devtype=web&v=1.0.1&rtick=14676158835111&share_qid=108635719&sign=b6d9213a3f8e89554dfc2d17b5b96980&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243069448532&size=800_600&devtype=web&v=1.0.1&rtick=14676158832484&share_qid=108635719&sign=51f3af5177e72e921191bb10d8df22b1&[/img]
[b][color=red]头文件[/color][/b] 

//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

[b][color=red]实现[/color][/b] 

#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;
    }
}

[b][color=red]客户端代码[/color][/b] 

#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();
}

[color=red][b]运行结果[/b][/color]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661259749436580&size=800_600&devtype=web&v=1.0.1&rtick=14661259835428&share_qid=108635719&sign=1e7b3d1f7ec4c44542ffe7ac6ec75b85&[/img]


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

[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=13770720602900003&size=800_600&devtype=web&v=1.0.1&rtick=14661259823327&share_qid=108635719&sign=5af638a1ceb66d14883911a7e6749948&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243049433736&size=800_600&devtype=web&v=1.0.1&rtick=14676161465014&share_qid=108635719&sign=f02a50bc7b18b6690722a3a8856d23a3&[/img]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661243049435715&size=800_600&devtype=web&v=1.0.1&rtick=14676161464510&share_qid=108635719&sign=cd091a60310162b91f19670048e8ee3a&[/img]
[b][color=red]头文件[/color][/b] 

//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

[b][color=red]实现[/color][/b] 

#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;
    }
}


[b][color=red]客户端代码[/color][/b] 

#include "SimpleFactoryPattern.h"

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

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

[color=red][b]运行结果[/b][/color]
[img]https://api5.yunpan.360.cn/intf.php?method=Share.getPublicThumbByNid&qid=108635719&nid=14661259749434622&size=800_600&devtype=web&v=1.0.1&rtick=14661259836990&share_qid=108635719&sign=398d4e3be18de7b3435b73bd32e00f36&[/img]
Jacky_Dai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式实例（简单工厂模式，工厂方法模式，抽象工厂模式）
qq_41185647的博客
05-04 5916
一、题目分析 (1)、简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 (2)、工厂方法模式 海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂...
三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式
LeBronJJJ的博客
09-02 623
工厂设计模式 工厂模式是用工厂方法代替new操作的一种模式。 在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 3种：简单工厂模式、工厂方法模式、抽象工厂模式。 适用场景 （1）在编码时不能预见需要创建哪种类的实例。 （2）系统不应依赖于产品类实例如何被创建、组合和表达的细节 （3）Spring框架的IOC就是使用的工厂模式 优点 （1）一个调用者想创建一个对...
设计模式：简单工厂、工厂方法、抽象工厂之小结与区别
热门推荐
superbeck的专栏
08-14 8万+
简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。 简单工厂简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。不修改代码的话，是无法扩展的。  工厂
UML图解简单工厂模式&工厂方法模式&抽象工厂模式区别
好记性不如烂笔头
05-15 5804
简述 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一； 工厂模式包含简单工厂模式&工厂方法模式&抽象工厂模式这三种； 这三者主要区别在于工厂实现的复杂度，以及是否符合“开发-封闭”原则； 工厂模式：说白了就是创建对象，使用Factory模式替代使用new创建对象。方便于维护对象； 简单工厂模式：使用参数或者配置文件等事先定义好的变量，然后利用分...
设计模式之简单工厂，工厂方法和抽象工厂
一个程序员的修炼之路
01-03 2789
在面向对象的编程中，一般通过继承和虚函数来提供抽象能力，多态让程序在执行期，调用者只需要看到父类类型，而不需要关心继承的子类类型。举个例子: 比如有个游戏，里面的游戏的活动对象为动物，比如有老虎和猫，会对主人公进行攻击。那么可能会实现为如下: 代码如下: class Animal { public: virtual void Attack() = 0; }; class Tiger : public Animal { public: virtual void Attack() { std::cout
[浪曦原创]JAVA设计模式 第4讲 抽象工厂(jzkangta)
09-08
学习这个模式时，需要注意理解抽象工厂模式与其他创建型模式（如简单工厂、工厂方法和建造者模式）的区别，以及如何在实际项目中合理选择和应用。同时，也要关注模式的优缺点，例如它能很好地封装变化，但可能会导致...
[浪曦原创]JAVA设计模式 第2讲 单态模式和简单工厂模式(jzkangta).rar
02-27
Java设计模式是软件开发中的重要概念，它们是解决常见...这个压缩包资料“[浪曦原创]JAVA设计模式 第2讲 单态模式和简单工厂模式(jzkangta)”应包含了详细的讲解和示例代码，可以帮助深入理解和应用这两种设计模式。
三种工厂模式（简单工厂、工厂方法、抽象工厂）简单理解
qq_35239471的博客
02-22 3143
一、简单工厂模式 例如:一个动物基类(抽象基类):描述什么是动物 N个动物类(继承抽象类):具体是什么动物,狗猫兔 一个工厂(根据不同条件生成创建不同动物): new cat ->猫 new dog ->狗 每次要添加一种动物类，工厂就要多加一个type。导致这个工厂类会变得非常繁重，甚至加入的这个type也可能再有变动。 二、工厂方法模式 例如:一个动物基类(抽象基类):描述什么是动物 N个动物类(继承抽象类):具体是什么动物,狗猫兔 一个抽象工厂接口(接口) 创建生产动物的工厂实现类(实
【设计模式系列1】深入分析简单工厂，工厂方法和抽象工厂三种设计模式
zwx900102的博客
05-06 3066
深入分析工厂设计模式 简单工厂设计模式(Simple Factory Pattern) 指的是由一个工厂对象来决定创建出哪一类产品种类的实例。简单工厂模式适用于工厂类负责创建较少对象的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。 工厂方法设计模式 抽象工厂模式 ...
【设计模式】简单工厂、工厂方法与抽象工厂的区别
李光 未来科技
06-09 3万+
前言 为什么会出现简单工厂，工厂方法与简单工厂还有抽象工厂到底有啥区别，什么时候能用到这些呢，如果你对于这些不是很清晰，那么你可以看看小编的这篇博客，透析式挖掘三者的区别！不要错过哟！ 这里所有的类图均用基本算法为例子，这样会有明显的对比！ 一、简单工厂模式 1、我们在实例化对象的时候通常用的是New关键字，但是有了工厂，我们在声明对象的时候就可以用工厂了，用new导致代码不够灵活，用工厂...
java 三种工厂模式(简单工厂+工厂方法+抽象工厂)
java小菜鸡成长之路
06-04 1万+
一、简单工厂模式 概述   简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的 实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法模式，它属于类创建型模式。 工厂模式结构图 简单工厂模式角色   在简单工厂模式结构图中包含如下几个角色： Factory（工厂角色）：工厂角色即工厂类，它是简单...
简单理解三种工厂模式（简单工厂模式，工厂方法模式和抽象工厂模式）
m0_51506743的博客
05-02 3320
区分三种工厂模式，简单工厂模式，工厂方法模式和抽象工厂模式。
浅谈简单工厂模式、工厂方法模式、抽象工厂模式
pp814274513的专栏
02-21 1089
浅谈简单工厂模式、工厂方法模式、抽象工厂模式 一、概述 简单说说对这几个设计模式的理解。名字相近，一几度弄不清这都是啥跟啥。 都叫xx工厂模式，顾名思义，工厂是要生产产品（在编程中就是类的实例对象）的。而这三种模式都是生产型模式，区别在于生产实例的方式、时机以及所能够达到编程原则约束、灵活性不同。 二、前情须知 上一段如何的最后一句话“所能够达到编程原则约束、灵活性不同”怎么理解呢？这还
java三种工厂模式：简单工厂、工厂方法、抽象工厂
xiaoddt的博客
07-11 1万+
java设计模式，工厂模式、简单工程、工厂方法、抽象工厂
简单工厂，工厂方法，抽象工厂 三种设计模式的区别和实例
bububu2012的专栏
07-09 538
简单工厂： 一个产品抽象类，可以派生很多具体产品类。 一个具体工厂类，可以创建多种具体的产品实例。 工厂方法： 一个抽象产品类，可以派生很多具体产品类。 一个抽象工厂类，可以派生很多具体工厂类。 每一个具体工厂可以创建多种具体的产品实例 抽象工厂类： 一个抽象产品类，可以派生很多产品基类。 每一个产品基类可以派生很多具体产品类 一个抽象工厂类，可以派生很多具
设计模式 第二节 工厂模式（Factory）
ellen艾琳的博客
09-05 119
设计模式第二节——工厂模式（Factory） 1、 使用场景：系统更换皮肤、spring-BeanFactory 简单工厂用于创建单一产品，经常和单例模式一起使用，例如用简单工厂创建缓存对象（ 文件缓存 ），某天需要改用 Redis 缓存，修改工厂即可。 Spring 中的BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean 对象 抽象工厂常用于创建一整个产品族，而不是单一产品。通过选择不同的工厂来达到目的，其优...
创建型设计模式解析：简单工厂、工厂方法、抽象工厂
"这篇教程详细介绍了创建型设计模式，其中包括简单工厂模式、工厂方法模式和抽象工厂模式。这些模式都是软件工程中用于高效创建对象的常用设计策略。由LSGO软件技术团队的马燕鹏分享，他强调了设计模式在实际开发中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值