简单工厂 / 工厂方法 / 抽象工厂

简单工厂

// 1个工厂对多个产品（简单的工厂模式）：工厂根据不同的参数创建对应的产品。
//优点：1.充分利用了多态性，不管什么具体产品都返回抽象产品。2.充分利用了封装性，内部产品发生变化时外部使用这不会受到影响。
//缺点：如果增加了新的产品，就必须的修改工厂，不满足闭合原则（多余的意思是工厂是唯一的）。
class AbstractProdect {//产品类的基类
public:
    virtual void Play() = 0;
};

class AbstractProdectA:public AbstractProdect{
public:
    AbstractProdectA() {
        cout << "AbstractProdectA()" << endl;
    }
    ~AbstractProdectA() {
        cout << "~AbstractProdectA()" << endl;
    }
    void Play() { cout << "I am AbstractProdectA" << endl; }
};

class AbstractProdectB :public AbstractProdect {
public:
    AbstractProdectB() {
        cout << "AbstractProdectB()" << endl;
    }
    ~AbstractProdectB() {
        cout << "~AbstractProdectB()" << endl;
    }
    void Play() { cout << "I am AbstractProdectB" << endl; }
};


class AbstractFactory {//工厂的基类
public:
    AbstractFactory() {};
    ~AbstractFactory() {};
    virtual AbstractProdect* CreateProdect(int) = 0;

};

class Factory1 :public AbstractFactory {
public:
    Factory1() { cout << "Factory1()" << endl; }
    ~Factory1() { cout << "~Factory1()" << endl; }
    AbstractProdect* CreateProdect(int chose)
    {
        AbstractProdect* pd;//指向生产的产品的指针
        switch (chose)
        {
        case 1:pd = new AbstractProdectA(); break;
        case 2:pd = new AbstractProdectB(); break;
        default:pd = NULL; break;
        }
        return pd;
    }


};

工厂方法

/*
工厂方法：有别于简单工厂却是简单工厂的升级。
不同之处、简单工厂是通过参数来控制产品的生产、这里使用的是重载。不同的工厂实现同一个工厂方法生产不同的产品。
、是一个工厂生产一个产品(一对一)。如需增加产品、首先要增加工厂。是一对一的生产模式。
优点：1.充分利用了多态性，不管什么具体产品都返回抽象产品。2.充分利用了封装性，内部产品发生变化时外部使用这不会受到影响。
工厂方法克服了简单工厂的缺点，增加新的产品时，不必修改现存的代码，而只需增加新代码。满足开闭原则。
*/
class Product {//产品的基类（抽象类）
public:
    Product() {}
    ~Product() {}
    virtual void ProBehave() = 0;
};

class productA :public Product {
public:
    productA() {}
    ~productA() {}
    void ProBehave() { cout << "productA " << endl; }
};

class productB :public Product {
public:
    productB() {}
    ~productB() {}
    void ProBehave() { cout << "productB " << endl; }
};

class productC :public Product {
public:
    productC() {}
    ~productC() {}
    void ProBehave() { cout << "productC " << endl; }
};

class Factory {//工厂类的基类（抽象类）
public:
    Factory() {}
    ~Factory() {}
    virtual Product* CreateProduct() = 0;//纯虚函数
};

class factoryA :public Factory {
public:
    factoryA() {}
    ~factoryA() {}
    Product* CreateProduct() { return new productA(); }
};

class factoryB :public Factory {
public:
    factoryB() {}
    ~factoryB() {}
    Product* CreateProduct() { return new productB(); }
};

class factoryC :public Factory {
public:
    factoryC() {}
    ~factoryC() {}
    Product* CreateProduct() { return new productC(); }
};

抽象工厂

/*
抽象工厂： 简单工厂+工厂方法（可以是多对多）
优点差不多是这两个优点的集合。
*/

class ProductA
{
public:
    ProductA()
    {}
    virtual ~ProductA()
    {}
public:
    virtual void operation() = 0;
};
class ProductA1 : public ProductA
{
public:
    ProductA1()
    {}
    virtual ~ProductA1()
    {}
public:
    virtual void operation()
    {
        cout << "ProductA1" << endl;
    }
};
class ProductA2 : public ProductA
{
public:
    ProductA2()
    {}
    virtual ~ProductA2()
    {}
public:
    virtual void operation()
    {
        cout << "ProductA2" << endl;
    }
};
class ProductB
{
public:
    ProductB()
    {}
    virtual ~ProductB()
    {}
public:
    virtual void operation() = 0;
};
class ProductB1 : public ProductB
{
public:
    ProductB1()
    {}
    virtual ~ProductB1()
    {}
public:
    virtual void operation()
    {
        cout << "ProductB1" << endl;
    }
};
class ProductB2 : public ProductB
{
public:
    ProductB2()
    {}
    virtual ~ProductB2()
    {}
public:
    virtual void operation()
    {
        cout << "ProductB2" << endl;
    }
};

class AbstractFactory
{
public:
    AbstractFactory()
    {}
    virtual ~AbstractFactory()
    {}
public:
    virtual ProductA* createProductA() = 0;
    virtual ProductB* createProductB() = 0;
};
class Factory1 : public AbstractFactory
{
public:
    Factory1()
    {}
    ~Factory1()
    {}
public:
    ProductA* createProductA()
    {
        return new ProductA1();
    }
    ProductB* createProductB()
    {
        return new ProductB1();
    }
};
class Factory2 : public AbstractFactory
{
public:
    Factory2()
    {}
    ~Factory2()
    {}
public:
    ProductA* createProductA()
    {
        return new ProductA2();
    }

    ProductB* createProductB()
    {
        return new ProductB2();
    }
};