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

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

简单工厂模式

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

//simpleFactory.h

#include 
#include 
//基类
class animal{
public:
    virtual void sleep() = 0;
};

//子类1
class cat :public animal{
public:
    void sleep(){
        std::cout << "cat sleep..." << std::endl;
    }
};

//子类2
class 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 
#include 


//基类
class animal{
public:
    virtual void sleep() = 0;
};

//子类1
class cat :public animal{
public:
    void sleep(){
        std::cout << "cat sleep..." << std::endl;
    }
};

//子类2
class 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 
#include 

//基类
class animal{
public:
    virtual void sleep() = 0;
};

//子类1
class whiteCat :public animal{
public:
    void sleep(){
        std::cout << "white cat sleep..." << std::endl;
    }
};

//子类2
class blackCat :public animal{
public:
    void sleep(){
        std::cout << "black cat sleep..." << std::endl;
    }
};

//子类3
class whiteDog :public animal{
public:
    void sleep(){
        std::cout << "white dog sleep..." << std::endl;
    }
};

//子类4
class 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...