工厂设计模式

工厂模式

这个代码里面使用了简单工厂模式，如果添加算子的话，需要增加标志位，因此不太好。

定义

工厂模式属于“创建型设计模式”，他提供了一种创建对象的方式，不会对客户端暴露创建对象的逻辑，并且使用抽象工厂提供的公共接口来完成对象的创建。

类图角色和职责

抽象工厂（Creator）角色：工厂方法模式的核心，任何工厂类都必须实现这个接口。
具体工厂（ Concrete Creator）角色：具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
抽象（Product）产品：工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：工厂方法模式所创建的具体实例对象

代码

#include 
using namespace std;
//产品抽象类
class AbstractFruit{
public:
    virtual void fruit() = 0;
};
//产品苹果，实现了fruit类
class Apple: public AbstractFruit{
public:
    virtual void fruit(){
        cout<<"这是一个苹果"<<endl;
    }
};
//香蕉产品，实现了fruit类
class Banana: public AbstractFruit{
public:
    virtual void fruit(){
        cout<<"这是一个香蕉"<<endl;
    }
};
//梨子产品，实现了fruit类
class Pear: public AbstractFruit{
public:
    virtual void fruit(){
        cout<<"这是一个鸭梨"<<endl;
    }
};

// 水果工厂 , 每个水果都增加一个抽象类
class AbstractFruitFactory{
public:
    virtual AbstractFruit* Create()=0;
};
// 苹果工厂
class AppleFactory : public AbstractFruitFactory{
public:
    virtual AbstractFruit* Create(){
        return new Apple;
    }
};
// 香蕉工厂
class BananaFactory : public AbstractFruitFactory{
public:
    virtual AbstractFruit* Create(){
        return new Banana;
    }
};
// 梨子工厂
class PearFactory : public AbstractFruitFactory{
public:
    virtual AbstractFruit* Create(){
        return new Pear;
    }
};
int main(int argc, char const *argv[])
{
    AbstractFruitFactory* factory1 = NULL; // 创建一个工厂
    AbstractFruit *fruit1 = NULL; // 创建一个水果工厂
    factory1 = new AppleFactory(); // 这个工厂是一个苹果工厂
    fruit1 = factory1->Create(); // 利用苹果工厂创建一个苹果
    fruit1->fruit();

    delete fruit1;
    delete factory1;
    return 0;
}

抽象工厂

定义

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

与工厂模式的区别：

工厂模式只能生产一个产品。（要么香蕉、要么苹果）
抽象工厂可以一下生产一个产品族（里面有很多产品组成）

模式中包含的角色和职责

抽象工厂（Creator）角色：抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。
具体工厂（ Concrete Creator）角色：具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
抽象（Product）产品：抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：抽象模式所创建的具体实例对象。

代码

// 抽象工厂针对产品族, 而不是产品等级结构
// 产品族: 同一个产地或者同一个工厂, 功能不同
// 产品等级: 功能相同, 厂商或者产地不同

// 中国工程: 苹果,鸭梨,香蕉: 
// 美国工程: 苹果,鸭梨,香蕉: 
// 鬼子工程: 苹果,鸭梨,香蕉: 

#include 
using namespace std;

// 抽象苹果
class AbstractApple{
    public:
    virtual void showName() = 0;
};

class ChinaApple: public AbstractApple{
    public:
    virtual void showName(){
        cout<<"中国苹果.."<<endl;
    }
};

class USApple: public AbstractApple{
    public:
    virtual void showName(){
        cout<<"美国苹果.."<<endl;
    }
};

class JPApple: public AbstractApple{
    public:
    virtual void showName(){
        cout<<"日本苹果.."<<endl;
    }
};


// 抽象香蕉
class AbstractBanana{
    public:
    virtual void showName() = 0;
};

class ChinaBanana: public AbstractBanana{
    public:
    virtual void showName(){
        cout<<"中国香蕉.."<<endl;
    }
};

class USBanana: public AbstractBanana{
    public:
    virtual void showName(){
        cout<<"美国香蕉.."<<endl;
    }
};

class JPBanana: public AbstractBanana{
    public:
    virtual void showName(){
        cout<<"日本香蕉.."<<endl;
    }
};

// 抽象鸭梨
class AbstractPear{
    public:
    virtual void showName() = 0;
};

class ChinaPear: public AbstractPear{
    public:
    virtual void showName(){
        cout<<"中国鸭梨.."<<endl;
    }
};

class USPear: public AbstractPear{
    public:
    virtual void showName(){
        cout<<"美国鸭梨.."<<endl;
    }
};

class JPPear: public AbstractPear{
    public:
    virtual void showName(){
        cout<<"日本鸭梨.."<<endl;
    }
};

// 抽象工厂
class AbstractFactory{
    public:
    virtual AbstractApple* createApple() = 0;
    virtual AbstractBanana* createBanana() = 0;
    virtual AbstractPear* createPear() = 0;
};
// 中国工厂
class ChinaFactory: public AbstractFactory{
    public:
    virtual AbstractApple* createApple(){return new ChinaApple;}
    virtual AbstractBanana* createBanana(){return new ChinaBanana;}
    virtual AbstractPear* createPear(){return new ChinaPear;}
};
// 美国工厂
class USFactory: public AbstractFactory{
    public:
    virtual AbstractApple* createApple(){return new USApple;}
    virtual AbstractBanana* createBanana(){return new USBanana;}
    virtual AbstractPear* createPear(){return new USPear;}
};
// 日本工厂
class JPFactory: public AbstractFactory{
    public:
    virtual AbstractApple* createApple(){return new JPApple;}
    virtual AbstractBanana* createBanana(){return new JPBanana;}
    virtual AbstractPear* createPear(){return new JPPear;}
};

void test01(){
    AbstractFactory*  factory = NULL;
    AbstractApple* apple = NULL;
    AbstractBanana* banan = NULL;
    AbstractPear* pear = NULL;

    factory = new ChinaFactory(); // 想吃中国工厂生产的水果就先建一个中国工厂
    apple = factory->createApple(); // 中国工厂生产一个aplle;
    banan = factory->createBanana(); 
    pear = factory->createPear();
    apple->showName(); // 吃掉这个苹果
    banan->showName(); // 吃掉这个苹果
    pear->showName(); // 吃掉这个苹果

    delete apple;
    delete banan;
    delete pear;
    delete factory;
}

int main(int argc, char const *argv[]){
    test01();
    cout<<"hello"<<endl;
    return 0;
}