设计模式之 -- 工厂模式

总结在先：
1、抽象工厂模式：一个工厂有多条生产线
同一基类中派生出来的所有产品都是由工厂构造的，新加产品之后，如何添加新产品？
直接写的话，会违反 开发-封闭原则
2、这个时候简单工厂模式就不适用了，需要用到工厂模式
工厂模式：给每一个产品生成一个工厂
3、多个基类指针指向派生类，派生类必须知道命名 为了提高扩展性和维护性
抽象工厂：创建一组相关或者相互依赖的对象，一个工厂生产一类产品

简单工厂：一个工厂类，一个抽象产品类，好几个产品类，根据工厂方法传入的参数决定生产哪个产品
普通工厂：一个抽象产品类，一个抽象工厂类，多个产品类对应多个工厂类，根据基类指针指向一个派生类，基类指针调用创建函数，动多态会自动调用相应的产品工厂的创建方法
抽象工厂： 多种抽象产品类，一个抽象工厂类，多种产品类，对应相应的工厂类，一个工厂生产一类产品，调用实现也是依赖动多态。

1. 简单工厂模式
   1.1 描述

简单工厂模式是由一个 “ 工厂对象 ” 根据收到的消息决定要创建哪一个类的对象实例。

1.2 使用场景

工厂类负责创建的对象比较少，客户只需要传入工厂类参数，对于如何创建对象（逻辑）不关心。

简单工厂模式很容易违反高内聚低耦合的原则，因此一般只在很简单的情况下使用。

1.3 优点
最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类

class AbstractProduct 抽象产品类
{
public:
    AbstractProduct(){}
    virtual ~AbstractProduct(){}
public:
    virtual void operation() = 0;
};

class Product_A :public AbstractProduct    产品A
{
public:
    Product_A(){}
    ~Product_A(){}
public:
    void operation()
    {
        cout << "Product_A" << endl;
    }
};
class Product_B : public AbstractProduct    产品B
{
public:
    Product_B(){}
    ~Product_B(){}
public:
    void operation()
    {
        cout << "Product_B" << endl;
    }
};

class SimpleFactory                         工厂类
{
public:
    SimpleFactory(){}
    ~SimpleFactory(){}
public:
    AbstractProduct* createProduct(int flag)     创建产品
    {
        switch (flag)
        {
        case 1:
            return new Product_A();
            break;
        case 2:
            return new Product_B();
            break;
        default:
            break;
        }
    }
};

2.1 描述
定义一个”创建对象” 的工厂接口，让”子类”决定实例化哪一个类，将实际创建工作推迟到子类当中。

2.2 使用场景
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。

2.3 优点

创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑判断移到了客户端。工厂方法模式克服了简单工厂所违背的 开闭原则 的缺点，又保持了封装对象创建过程的优点。扩展性高，想要增加一个产品，只要扩展一个工厂类就可以。

设计模式原则：
1.依赖倒置原则
依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
2.开发-封闭原则
开发过程中，可以以前的代码，但是不能修改 向前兼容

/*
    工厂模式

*/
class AbstractProduct          //抽象产品类
{
public:
    AbstractProduct(){}
    virtual ~AbstractProduct(){}
public:
    virtual void operation() = 0;
};

class Product_A :public AbstractProduct    //A产品类
{
public:
    Product_A(){}
    ~Product_A(){}
public:
    void operation()
    {
        cout << "Product_A" << endl;
    }
};

class Product_B : public AbstractProduct     //B产品类
{
public:
    Product_B(){}
    ~Product_B(){}
public:
    void operation()
    {
        cout << "Product_B" << endl;
    }
};

class AbstractFactory                       //抽象工厂类
{
public:
    AbstractFactory(){}
    virtual ~AbstractFactory(){}
public:
    virtual AbstractProduct* createProduct() = 0;
};

class Factory_A : public AbstractFactory     //A工厂类 生产A产品
{
public:
    Factory_A(){}
    ~Factory_A(){}
public:
    AbstractProduct* createProduct()
    {
        return new Product_A();
    }
};

class Factory_B : public AbstractFactory    //B工厂类  生产B产品
{
public:
    Factory_B(){}
    ~Factory_B(){}
public:
    AbstractProduct* createProduct()
    {
        return new Product_B();
    }
};

class Product_C : public AbstractProduct    // C产品类
{
public:
    Product_C(){}
    ~Product_C(){}
public:
    void operation()
    {
        cout << "Product_C" << endl;
    }
};

class Factory_C : public AbstractFactory    // C工厂类 生产C产品
{
public:
    Factory_C(){}
    ~Factory_C(){}
public:
    AbstractProduct* createProduct()
    {
        return new Product_C();
    }
};

抽象工厂模式

3.1 描述
抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

3.2 使用场景
系统的产品多于一个产品族，而系统只消费某一族的产品。

3.3 优点
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

class AbstractProductA          // A产品抽象类
{
public:
    virtual ~AbstractProductA(){}
public:
    virtual void operation() = 0;
};


class Product_A1 : public AbstractProductA    // A1 产品类
{
public:
    virtual ~Product_A1(){}
public:
    void operation()
    {
        cout << "Product_A1" << endl;
    }
};

class Product_A2 : public AbstractProductA   // A2  产品类
{
public:
    virtual ~Product_A2(){}
public:
    void operation()
    {
        cout << "Product_A2" << endl;
    }
};

class AbstractProductB                  // B产品抽象类
{
public:
    virtual ~AbstractProductB(){}
public:
    virtual void operation() = 0;
};

class Product_B1 : public AbstractProductB     //B1产品类
{
public:
    virtual ~Product_B1(){}
public:
    void operation()
    {
        cout << "Product_B1" << endl;
    }
};

class Product_B2 : public AbstractProductB     //B2产品类
{
public:
    virtual ~Product_B2(){}
public:
    void operation()
    {
        cout << "Product_B2" << endl;
    }
};

class  AbstractFactory                 //抽象工厂类
{
public:
    virtual ~AbstractFactory(){}
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class Factory_1 : public AbstractFactory      // 1号产品工厂类
{
public:
    ~Factory_1(){}
public:
    AbstractProductA* createProductA()
    {
        return new Product_A1();
    }
    AbstractProductB* createProductB()
    {
        return new Product_B1();
    }
};

class Factory_2 : public AbstractFactory      // 2号产品工厂类
{ 
public:
    ~Factory_2(){}
public:
    AbstractProductA* createProductA()
    {
        return new Product_A2();
    }
    AbstractProductB* createProductB()
    {
        return new Product_B2();
    }
};

int main()
{
    AbstractFactory* paf = new Factory_2();
    AbstractProductA* papa= paf->createProductA();
    papa->operation();

    //AbstractFactory* Base = new Factory_A();
    //AbstractProduct* pap = Base->createProduct();
    //pap->operation();


    //SimpleFactory sf;
    //AbstractProduct* ap = sf.createProduct(2);
    //ap->operation();//动态多态
    return 0;
}