【设计模式】工厂模式——创建对象的最佳方式

工厂模式中，创建对象时不会对客户端暴露创建逻辑，通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

运用面向对象的继承和多态，将对象的创建放到工厂中，根据需求（用参数表明），来判断需要什么类型的对象，就创建什么类型的对象。一个简单的例子：

//simpleFactory.h

#include <iostream>#include <string>//基类class animal{public:    virtual void sleep() = 0;};//子类1class cat :public animal{public:    void sleep(){        std::cout << "cat sleep..." << std::endl;    }};//子类2class dog :public animal{public:    void sleep(){        std::cout << "dog sleep..." << std::endl;    }};//简单工厂class animalFactory{public:    animalFactory(){};    animal *getAnimal(std::string animalType){        //判断需要什么类型的animal，就创建什么类型的animal        //利用了面向对象的多态        if (animalType.empty()){            std::cout << "no animal type input..." << std::endl;            return nullptr;        }        if (animalType == "dog"){            return new dog();        }        if (animalType == "cat"){            return new cat();        }    }};

main.cpp

#include "simpleFactory.h"int main(){    animalFactory an;    animal *dog = an.getAnimal("dog");    dog->sleep();    animal *cat = an.getAnimal("cat");    cat->sleep();    system("pause");    return 0;}

输出：

dog sleep...cat sleep...

工厂方法模式

简单工厂模式是一种用于创建对象的好方法，但它有一个很致命的缺点，就是如果要增加产品类型，就要修改工厂类，这违反了设计模式的“开放关闭”原则（对扩展开放，对修改关闭），在此基础上，出现了工厂方法模式，其原理就是将每一种产品的创建分别设计一个工厂，这样，增加产品不需要改变工厂类，但其缺点是需要增加一个对应产品的工厂。

factoryFunction.h

#include <iostream>#include <string>//基类class animal{public:    virtual void sleep() = 0;};//子类1class cat :public animal{public:    void sleep(){        std::cout << "cat sleep..." << std::endl;    }};//子类2class dog :public animal{public:    void sleep(){        std::cout << "dog sleep..." << std::endl;    }};//工厂抽象class animalFactory{public:    animalFactory(){};    virtual animal *getAnimal() = 0;};//狗狗工厂class dogFactory :public animalFactory{public:    dog*getAnimal(){        return new dog();    }};//猫咪工厂class catFactory :public animalFactory{public:    cat*getAnimal(){        return new cat();    }};

mian.cpp

#include "factoryFunction.h"int main(){    dogFactory dogF;    animal *dog1 = dogF.getAnimal();    dog1->sleep();    catFactory catF;    animal *cat1 = catF.getAnimal();    cat1->sleep();    system("pause");    return 0;}

输出

dog sleep...cat sleep...

抽象工厂模式

一个工厂通常不会只生产一种类型产品，也可以生产相似类型产品，抽象工厂模式就是将相似的产品放到一个工厂中生产，而不必要重新建设一个工厂，实例中，白猫和黑猫是相似的产品，所以可以在同一个工厂中生产。

abstractFectory.h

#include <iostream>#include <string>//基类class animal{public:    virtual void sleep() = 0;};//子类1class whiteCat :public animal{public:    void sleep(){        std::cout << "white cat sleep..." << std::endl;    }};//子类2class blackCat :public animal{public:    void sleep(){        std::cout << "black cat sleep..." << std::endl;    }};//子类3class whiteDog :public animal{public:    void sleep(){        std::cout << "white dog sleep..." << std::endl;    }};//子类4class blackDog :public animal{public:    void sleep(){        std::cout << "balck dog sleep..." << std::endl;    }};//工厂抽象class animalFactory{public:    animalFactory(){};    virtual animal *getBlackAnimal() = 0;    virtual animal *getWhiteAnimal() = 0;};//狗狗工厂class dogFactory :public animalFactory{public:    whiteDog *getWhiteAnimal(){        return new whiteDog();    }    blackDog *getBlackAnimal(){        return new blackDog();    }};//猫咪工厂class catFactory :public animalFactory{public:    whiteCat *getWhiteAnimal(){        return new whiteCat();    }    blackCat *getBlackAnimal(){        return new blackCat();    }};

main.cpp

#include "abstractFectoryPattren.h"int main(){    dogFactory dogF;    whiteDog *wd = dogF.getWhiteAnimal();    wd->sleep();    blackDog *bd = dogF.getBlackAnimal();    bd->sleep();    catFactory catF;    whiteCat *wc = catF.getWhiteAnimal();    wc->sleep();    blackCat *bc = catF.getBlackAnimal();    bc->sleep();    system("pause");    return 0;}

输出

white dog sleep...balck dog sleep...white cat sleep...black cat sleep...