工厂模式(factory pattern)

工厂模式主要用来封装对象的创建，有3种分类：简单工厂(simple factory)、工厂方法(factory method)、抽象工厂(abstract factory)。

简单工厂包括3种组成元素：抽象产品、具体产品、具体工厂(简单工厂)，结构图如下：

C++实现：

//抽象产品
class Car {
public:
    virtual string getDescription() = 0;
};
//具体产品
class Audi : public Car {
    string getDescription() { return "Audi"; }
};

class BMW : public Car {
    string getDescription() { return "BMW"; }
};

class Ford : public Car {
    string getDescription() { return "Ford"; }
};

class Hummer : public Car {
    string getDescription() { return "Hummer"; }
};

class Toyota : public Car {
    string getDescription() { return "Toyota"; }
};

class Bentley : public Car {
    string getDescription() { return "Bentley"; }
};
//简单工厂
class CarFactory {
public:
    static Car* createCar(string name) {
        if (name == "Audi")
            return new Audi;
        else if (name == "BMW")
            return new BMW;
        else if (name == "Ford")
            return new Ford;
        else if (name == "Hummer")
            return new Hummer;
        else if (name == "Toyota")
            return new Toyota;
        else if (name == "Bentley")
            return new Bentley;
    }
};

int main()
{
    Car *mycar = CarFactory::createCar("Audi");
    cout << mycar->getDescription() << endl;
    mycar = CarFactory::createCar("BMW");
    cout << mycar->getDescription() << endl;
    delete mycar;
}

可以看出，在简单工厂模式下，一个具体的工厂负责所有具体产品的创建，适用于产品种类较少的情况。当新增产品时，我们需要修改简单工厂的实现逻辑，违背了开放关闭原则。

工厂方法模式在简单工厂模式基础上，增加了一个抽象工厂。

抽象工厂只定义了创建对象的接口，由具体子类负责具体对象的创建。

C++实现：

//抽象工厂
class CarFactory {
public:
    virtual Car* createCar() = 0;
};
//具体工厂
class AutiCarFactory : public CarFactory {
public:
    Car* createCar() { return new Audi; }
};

class BMWCarFactory : public CarFactory {
public:
    Car* createCar() { return new BMW; }
};

int main()
{
    CarFactory *pcf = new AutiCarFactory;
    Car *c = pcf->createCar();
    cout << c->getDescription() << endl;
    delete pcf;

    pcf = new BMWCarFactory;
    c = pcf->createCar();
    cout << c->getDescription() << endl;
    delete pcf;
}

在工厂方法模式下，当新增一个产品种类时，只需要创建一个新的产品类和一个新的对应工厂类即可，没有破坏原有代码，遵循了开放关闭原则。