1.工厂模式

Posted 2020-08-08 不忘初心 方得始终

一、工厂模式

（1）简单工厂模式

　　例：一个工厂只能够生产两种产品A和B，客户需要什么产品一定要显示地告诉工厂。　　

　　这种设计方式的缺点：

　　　　要增加新产品时，需要修改工厂类。

　　　　违背了开放封闭原则：软件实体（类、模板、函数）可以扩展，但不可以修改。所以工厂方法模式出现了。

//产品类型
enum TYPE { TYPEA, TYPEB };

//产品基类
class CProduct {
public:
    virtual void Show() = 0;
};

//A产品类
class CProductA : public CProduct {
public:
    virtual void Show() { std::cout << "Production A." << std::endl; }
};

//B产品类
class CProductB : public CProduct {
public:
    virtual void Show() { std::cout << "Production B." << std::endl; }
};

//工厂类，可以生产两种产品
class CFactory {
public:
    CProduct* CreateProduct(TYPE type) {
        if (TYPEA == type) {
            return new CProductA;
        }
        if (TYPEB == type) {
            return new CProductB;
        }
        return nullptr;
    }
};

（2）工厂方法模式

　　工厂方法模式是对每种产品单独建一个工厂，客户需要某种产品直接找生产该产品的工厂，就不需要告诉工厂产品类型。

　　这种设计方式的缺点是：每增加一种新产品就要增加一个新工厂。这样，就要定义更多的类。

//产品类型
enum TYPE { TYPEA, TYPEB };

//产品基类
class CProduct {
public:
    virtual void Show() = 0;
};

//A产品类
class CProductA : public CProduct {
public:
    virtual void Show() { std::cout << "Production A." << std::endl; }
};

//B产品类
class CProductB : public CProduct {
public:
    virtual void Show() { std::cout << "Production B." << std::endl; }
};

//生产产品A的工厂
class CFactoryA {
public:
    CProductA* CreateProductA() { return new CProductA; }
};

//生产产品B的工厂
class CFactoryB {
public:
    CProductB* CreateProductB() { return new CProductB; }
};

（3）抽象工厂模式

　　假设这家公司技术进步，不仅可以生产A和B，还能生产改进型A1和B1，现在简单工厂模式和工厂方法模式是不合适的。因此，抽象工厂模式出现了，

　　它定义了一个创建一些列或相互依赖对象的接口，而无需指定它们具体的类，这样还是两个工厂，一个生产A和A1，另一个生产B和B1。　

//产品类型
enum TYPE { TYPEA, TYPEB };

//产品基类
class CProduct {
public:
    virtual void Show() = 0;
};

//A产品类
class CProductA : public CProduct {
public:
    virtual void Show() { std::cout << "Production A." << std::endl; }
};

//B产品类
class CProductB : public CProduct {
public:
    virtual void Show() { std::cout << "Production B." << std::endl; }
};

//改进型产品基类
class CProductUpdated {
public:
    virtual void Show() = 0;
};

//改进型产品A
class CProductA1 : public CProductUpdated {
public:
    virtual void Show() { std::cout << "Product A1." << std::endl; }
};

//改进型产品B
class CProductB1 : public CProductUpdated {
public:
    virtual void Show() { std::cout << "Product B1." << std::endl; }
};

//工厂类
class CFactory {
public:
    virtual CProduct* CreateProuct() = 0;
    virtual CProductUpdated* CreateProductUpdated() = 0;
};

//生产A和A1的工厂
class CFactoryA : public CFactory {
public:
    virtual CProduct* CreateProuct() { return new CProductA; }
    virtual CProductUpdated* CreateProductUpdated() { return new CProductA1; }
};

//生产B和B1的工厂
class CFactoryB : public CFactory {
public:
    virtual CProduct* CreateProuct() { return new CProductB; }
    virtual CProductUpdated* CreateProductUpdated() { return new CProductB1; }
};