创建型之工厂设计模式

1. 简单工厂模式原理/优缺点/适应场景

        简单的说是使用C++多态/继承的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在介绍工厂设计模式之前，首先介绍简单工厂设计模式。

MODEL: 鞋厂可以指定生产耐克、阿迪达斯和李宁牌子的鞋子。哪个鞋炒的火爆，老板就生产哪个，看形势生产。

1.1.1 UML图

 

1.1.2 简单工厂模式的结构组成

        1.工厂类： 工厂类的核心类，定义一个用于创建指定实例对象的接口。

        2.抽象产品类：是具体产品类的继承的父类或者实现的接口。

        3.具体产品类：工厂类所创建的对象就是此具体的实现。

1.1.3 简单工厂模式的特点

        工厂类封装了创建具体产品对象的函数（也就是对抽象产品类中接口的实现）

1.1.4 优缺点

        缺点：扩展性差，增加产品的时候，需要去修改工厂类。这就违反了开放封闭原则。

        优点：

#include <iostream>
#include "stdafx.h"

using namespace std;

class Shoes   // 抽象产品类
{
    public:
    virtual ~Shoes() = default;
    virtual void show() = 0;
};

class Nike : public Shoes  // 具体产品类
{
    public:
    void show()
    {
        // 实现
    }
};

class Adidas : public Shoes  // 具体产品类
{
    public:
    void show()
    {
        // 实现
    }
};

class LiNing : public shoes  // 具体产品类
{
    public:
    void show()
    {
        // shixian
    }
};

enum SHOES
{
    nike;
    adidas;
    lining;
}

class ShoesFactory   // 工厂类
{
public:

    Shoes *creatShoes(SHOES shoes)
    {
        switch(shoes)
        {
        case nike:
            return new Nike();
            break;
        case adidas:
            return new Adidas();
            break;
        case lining:
            return new LiNing();
            break;
        default:
            return NULL;
            break;
        }
    }
};


int main()
{
    ShoesFactory shoesFactory;
    Shoes *pNike = shoesFactory.creatShoes(nike);
    if (pNike != NULL)
    {
        pNike->show();
    
        delete pNike;
        pNike = NULL;
    }
    return 0;
}

为了解决简单工厂类的缺点，引入了工厂类。

 2. 工厂模式原理/优缺点/适应场景

MODEL: 现各类鞋子抄的非常火热，于是为了大量生产每种类型的鞋子，则要针对不同品牌的鞋子开设独立的生产线，那么每个生产线就只能生产同类型品牌的鞋。。

2.1.1 UML图

 

 

2.1.2 简单工厂模式的结构组成

        1.抽象工厂类：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。

        2.具体工厂类：继承于抽象工厂，实现创建对应具体产品对象的方式。

        3.抽象产品类：它是具体产品继承的父类（基类）。

        4.具体产品类：具体工厂所创建的对象，就是此类。

2.1.3 简单工厂模式的特点

        1.工厂方法模式抽象出了工厂类，提供创建具体产品的接口，交由子类去实现。

         2.工厂方法模式的应用并不只是为了封装具体产品对象的创建，而是要把具体产品对象的创建放到具体工厂类实现。

2.1.4 优缺点

        每新增一个产品，就需要增加一个对应的产品的具体工厂类。相比简单工厂模式而言，工厂方法模式需要更多的类定义。

        一条生产线只能一个产品。

#include <iostream>
#include "stdafx.h"

using namespace std;

class Shoes   // 抽象产品类
{
    public:
    virtual ~Shoes() = default;
    virtual void show() = 0;
};

class Nike : public Shoes  // 具体产品类
{
    public:
    void show()
    {
        // 实现
    }
};

class Adidas : public Shoes  // 具体产品类
{
    public:
    void show()
    {
        // 实现
    }
};

class LiNing : public shoes  // 具体产品类
{
    public:
    void show()
    {
        // shixian
    }
};

enum SHOES
{
    nike;
    adidas;
    lining;
}

class ShoesFactory   // 抽象工厂类
{
public:
    virtual ~ShoesFactory() = default;
    virtual Shoes *create() = 0;
};

class NikeFactory : public ShoesFactory
{
    public:
    Shoes *create()
    {
        return new Nike();
    }
};

class AdidasFactory : public ShoesFactory
{
    public:
    Shoes *create()
    {
        return new Adidas();
    }
};

class LiNingFactory : public ShoesFactory
{
    public:
    Shoes *create()
    {
        return new LiNing();
    }
};


int main()
{
    ShoesFactory *shoesFactory = new NikeFactory();
    Shoes *shoes = shoesFactory->create();
    shoes->show();
    delete shoes;
    delete shoesFactory;
    
    return 0;
}