工厂模式＜＜简单工厂模式，工厂模式和抽象工厂模式

最新推荐文章于 2024-05-14 15:42:06 发布

ggj的球球

最新推荐文章于 2024-05-14 15:42:06 发布

阅读量158

点赞数

分类专栏：设计模式C++版文章标签：简单工厂模式抽象工厂模式

原文链接：https://blog.csdn.net/weixin_71511408/article/details/127435038

版权

设计模式C++版专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.定义：将工厂变成一个抽象类，在里面定义一个纯虚函数，具体生成了什么产品交给子类继承去决定（抽象产品类->具体产品类->抽象工厂类->具体工厂类）

2.作用：封装函数的创建，解决new耦合的问题（解耦）

3.使用场景：用来生产同一等级结构中的固定产品。（支持增加任意产品）

4.实例：水果例子；数据库访问；

5.优点：当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体工厂对象，原有工厂对象不需要进行任何修改，符合开闭原则。

6.缺点：每增加一个产品就要增加一个产品工厂的类，增加了额外的开发量。

简单理解就是抽象类里面不能new，需要用他的派生类那边实现，抽象类这样就可以不修改。

简单工厂

1.定义：一个工厂方法，依据传入的参数，生成对应的产品对象。

2.角色：抽象产品类；具体产品；工厂类

3.使用说明：先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类Fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨；

4.简单工厂模式的优缺点：
     在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

#include <iostream>
#include <queue>
#include <time.h>
using namespace std;
class Fruit
{
public:
    virtual void show() = 0;
};
class Apple : public Fruit
{
public:
    void show()
    {
        cout << "this is Apple" << endl;
    }
};
class Banana : public Fruit
{
public:
    void show()
    {
        cout << "this is Banana" << endl;
    }
};
class pear : public Fruit
{
public:
    void show()
    {
        cout << "this is pear" << endl;
    }
};
class Factory
{
public:
    Fruit *CreateApple()
    {
        return new Apple;
    }
    Fruit *CreateBanana()
    {
        return new Banana;
    }
    Fruit *CreatePear()
    {
        return new pear;
    }
};
int main(int argc, char const *argv[])
{
    Factory *f = new Factory;
    Fruit *Fruit;
    Fruit = f->CreateApple();
    Fruit->show();
    Fruit = f->CreateBanana();
    Fruit->show();
    Fruit = f->CreatePear();
    Fruit->show();
    return 0;
}

（2）工厂模式：

1.定义:将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定

2.角色：抽象产品类；具体产品类；抽象工厂类；具体工厂类；模式中包含的角色及其职责。

3.使用说明：和上列中一样，产品抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定。

4.工厂方法模式和简单工厂模式比较：
     工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

#include <iostream>
#include <queue>
#include <time.h>
//工厂模式：在之前的简单工厂模式上进行改进，实现了高内聚，低耦合
using namespace std;
class Fruit
{
public:
    virtual void show();
};
class Apple : public Fruit
{
public:
    void show()
    {
        cout << "this is Apple" << endl;
    }
};
class Banana : public Fruit
{
public:
    void show()
    {
        cout << "this is Banana" << endl;
    }
};
class pear : public Fruit
{
public:
    void show()
    {
        cout << "this is pear" << endl;
    }
};
class Factory
{
public:
    virtual Fruit *Create() = 0;
};
class AppleFactory : public Factory
{
public:
    Fruit *Create()
    {
        return new Apple;
    }
};
class BananaFactory : public Factory
{
public:
    Fruit *Create()
    {
        return new Banana;
    }
};
class PearFactory : public Factory
{
public:
    Fruit *Create()
    {
        return new pear;
    }
};
int main(int argc, char const *argv[])
{
    Factory *f = new AppleFactory;
    Fruit *Fruit = f->Create();
    Fruit->show();
    delete f;
    delete Fruit;
    f = new PearFactory;
    Fruit = f->Create();
    Fruit->show();
    return 0;
}
```**

## 抽象工厂模式

**

> 1.定义：为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定他们的具体类。
> 
> 2.角色：与工厂模式一样
> 
> 3.使用说明：
> 
>          抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；举个例子，假如生产小米手机，小米手机有很多系列，小米note、红米note等；假如小米note生产需要的配件有825的处理器，6英寸屏幕，而红米只需要650的处理器和5寸的屏幕就可以了；用抽象工厂来实现。

```cpp
#include <iostream>
#include <queue>
#include <time.h>
using namespace std;
//工厂模式：在之前的简单工厂模式上进行改进，实现了高内聚，低耦合
class Fruit
{
public:
    virtual void show() = 0;
};
class NorthApple : public Fruit
{
public:
    void show()
    {
        cout << "this is NorthApple" << endl;
    }
};
class SouthApple : public Fruit
{
public:
    void show()
    {
        cout << "this is SouthApple" << endl;
    }
};
class NorthBanana : public Fruit
{
public:
    void show()
    {
        cout << "this is NorthBanana" << endl;
    }
};
class SouthBanana : public Fruit
{
public:
    void show()
    {
        cout << "this is SouthBanana" << endl;
    }
};
class Factory
{
public:
    virtual Fruit *CreateApple();
    virtual Fruit *CreateBanana();
};
class NorthFactory : public Factory
{
public:
    Fruit *CreateApple()
    {
        return new NorthApple;
    }
    Fruit *CreateBanana()
    {
        return new NorthBanana;
    }
};
class SouthFactory : public Factory
{
public:
    Fruit *CreateApple()
    {
        return new SouthApple;
    }
    Fruit *CreateBanana()
    {
        return new SouthBanana;
    }
};
void Create(Factory *f)
{
    Fruit *fruit;
    fruit = f->CreateApple();
    fruit->show();
    delete fruit;
    fruit = f->CreateBanana();
    fruit->show();
    delete fruit;
}
int main(int argc, char const *argv[])
{
    Factory *f = new SouthFactory;
    Create(f);
    delete f;
    f = new NorthFactory;
    Create(f);
    return 0;
}