设计模式专题--简单工厂、工厂、抽象工厂

一、前言

简单工厂模式、工厂模式、抽象工厂模式，虽然分为三个设计模式，但是有一些共通的地方，而在学习的时候常常会分不清这三种模式的区别，不知道该怎么去合理的使用这三种模式。本篇文章通过融合对三种模式的具体实现进行分析，来区别开三种设计模式。

二、模式介绍

1、简单工厂模式

简单工厂模式，通过创建一个专门定义的工厂类，来负责创建其他的具体产品的实例。工厂创建的具体的实例是通过传入的参数来进行创建需要的具体的实例，当添加或者删除具体的实例时，同时需要修改当前的工厂，不符合开闭原则。

2、工厂模式

工厂模式是定义创建产品对象的工厂的接口，将实际创建的工作推迟到子类当中。每个产品对应着相应的工厂，增加相关的实例时，只需要根据工厂对象的接口，增加相应的工厂子类。

3、是抽象工厂模式

抽象工厂和工厂模式比较相像，解决了工厂模式只能创建单个实例的问题。抽象工厂模式可以向客户端提供一个接口，使得客户端不比指定具体的产品类型的情况下，能够创建多个产品族的产品对象。

三、具体代码实现分析

产品类：

.h

/**
 * @brief The Fruit class
 * 设计一个父类，包含一个纯虚函数
 * 如果需要其他的功能，可以添加其他的虚函数
 */
class Fruit
{
public:
    /*纯虚函数，由子类实现打印水果的名字*/
    virtual void fruitName() = 0;
};

class Banana : public Fruit
{
public:
    virtual void fruitName();
};

class Apple : public Fruit
{
public:
    virtual void fruitName();
};

class Orange : public Fruit
{
public:
    virtual void fruitName();
};

.cpp

using namespace std;

void Banana::fruitName()
{
    cout<<"I am banana"<<endl;
}

void Apple::fruitName()
{
    cout<<"I am Apple"<<endl;
}

void Orange::fruitName()
{
    cout<<"I am Orange"<<endl;
}

 

工厂类：

.h

/*************************************************************************
 * 名  称：简单工厂模式
 * 注  释：负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
 * 优缺点：包含必要的逻辑判断，能够通过外界给定的信息，决定应该创建哪个对象。
 *        但是这样的做法破坏了开闭原则，当具体产品类增加时，要相应的去修改工厂类。
 *        因此简单工厂模式不能算作真正的设计模式。
 * ************************************************************************/
class SimpleFactory
{
public:
    //根据传入的名字来初始化创建的水果
    Fruit *creatFruit(const QString &name);
};

/*************************************************************************
 * 名  称：工厂模式
 * 注  释：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
 * 优缺点：很好的符合了开闭原则，但是每创建一个实例都需要创建相应的工厂，需要较多的代码。
 * ************************************************************************/
class Factory
{
public:
    virtual Fruit *creatFruit() = 0;

};
/*工厂模式--Banana工厂*/
class BananaFactory : public Factory
{
public:
    //创建Banana
    virtual Fruit *creatFruit();
};
/*工厂模式--Aplle工厂*/
class AppleFactory : public Factory
{
public:
    //创建Apple
    virtual Fruit *creatFruit();
};
/*工厂模式--Orange工厂*/
class OrangeFactory : public Factory
{
public:
    //创建Orange
    virtual Fruit *creatFruit();
};

/*************************************************************************
 * 名  称：抽象工厂模式
 * 注  释：抽象工厂可以向客户端提供一个接口，使得客户端不比指定具体类型，能够创建出多个产品族的对象产品。
 * 优缺点：解决了工厂模式只能生产单一产品的缺陷，抽象工厂能够生产一个产品族。
 * ************************************************************************/
class AbstractFactory
{
public:
    virtual Fruit *creatFruit1() = 0;
    virtual Fruit *creatFruit2() = 0;
};
/*抽象工厂模式--工厂1*/
class AbstractFactory1 : public AbstractFactory
{
public:
    //创建Banana
    virtual Fruit *creatFruit1();
    //创建Apple
    virtual Fruit *creatFruit2();
};
/*抽象工厂模式--工厂2*/
class AbstractFactory2 : public AbstractFactory
{
public:
    //创建Orange
    virtual Fruit *creatFruit1();
    //创建Banana
    virtual Fruit *creatFruit2();
};

.cpp

 

Fruit *SimpleFactory::creatFruit(const QString &name)
{
    if (name == "apple") {
        return new Apple;
    } else if (name == "banana") {
        return new Banana;
    } else if (name == "orange") {
        return new Orange;
    }
    return NULL;
}

Fruit *BananaFactory::creatFruit()
{
    return new Banana;
}
Fruit *AppleFactory::creatFruit()
{
    return new Apple;
}
Fruit *OrangeFactory::creatFruit()
{
    return new Orange;
}

Fruit *AbstractFactory1::creatFruit1()
{
    return new Banana;
}
Fruit *AbstractFactory1::creatFruit2()
{
    return new Apple;
}

Fruit *AbstractFactory2::creatFruit1()
{
    return new Orange;
}
Fruit *AbstractFactory2::creatFruit2()
{
    return new Banana;
}

工厂使用：

.h

/* 工厂模式使用*/
class UseFactory
{
public:
    UseFactory();
};

.cpp

 

UseFactory::UseFactory()
{
    /*简单工厂模式使用*/
    SimpleFactory *simpleFactory = new SimpleFactory;
    Fruit *fruit = simpleFactory->creatFruit("apple");
    fruit->fruitName();
    delete fruit;

    fruit = simpleFactory->creatFruit("banana");
    fruit->fruitName();
    delete fruit;
    delete simpleFactory;
    
    /*工厂模式使用*/
    Factory *factory = NULL;
    fruit  = NULL;
    factory = new AppleFactory;
    fruit = factory->creatFruit();
    fruit->fruitName();
    delete fruit;
    delete factory;

    factory = new BananaFactory;
    fruit = factory->creatFruit();
    fruit->fruitName();
    delete fruit;
    delete factory;

    /*抽象工厂使用*/
    AbstractFactory *abstractFactory = NULL;
    Fruit *fruit1 = NULL;
    Fruit *fruit2 = NULL;
    abstractFactory = new AbstractFactory1;
    fruit1 = abstractFactory->creatFruit1();
    fruit2 = abstractFactory->creatFruit2();
    fruit1->fruitName();
    fruit2->fruitName();
    delete fruit1;
    delete fruit2;

    abstractFactory = new AbstractFactory2;
    fruit1 = abstractFactory->creatFruit1();
    fruit2 = abstractFactory->creatFruit2();
    fruit1->fruitName();
    fruit2->fruitName();
    delete fruit1;
    delete fruit2;
    delete abstractFactory;
}

四、总结

    三种工厂模式都是通过相同的具体实例类来进行实现，简单工厂模式，通过在工厂类中传入的参数进行创建相应的实例，工厂模式则是创建一个工厂类，由子类来实现具体的实例的创建，抽象工厂模式也是创建一个工厂类，由子类来实现具体的实例的创建，并且可以在类中创建多个实例对象。