设计模式学习笔记2-抽象工厂

C++代码：

#include <iostream>
#include <cstdio>
#include <string>
#include <system_error>
#include <vector>
#include <stack>
using  namespace std;

// 创建抽象工厂类，定义具体工厂的公共接口
class AbstractProduct;
class Factory{
public:
    AbstractProduct* ManufactureContainer();
    AbstractProduct* ManufactureMould();
};

// 创建抽象产品族类 ，定义具体产品的公共接口
class AbstractProduct{
    public:
    virtual void Show() = 0;
};

// 创建抽象产品类 ，定义具体产品的公共接口；

// 容器产品抽象类
 class ContainerProduct : public AbstractProduct{
    //@Override
    public:
      virtual void Show() = 0;
};

//模具产品抽象类
 class MouldProduct  : public AbstractProduct{
    //@Override
    public:
     virtual  void Show() = 0;
};

//  创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
//容器产品A类
class ContainerProductA  : public ContainerProduct{
    //@Override
    public:
     void Show() {
        printf("product container productA\n");
    }
};

//容器产品B类
class ContainerProductB  :public ContainerProduct{
    //@Override
    public:
     void Show() {
        printf("product container productB\n");
    }
};

//模具产品A类
class MouldProductA  :public MouldProduct{

    //@Override
    public:
     void Show() {
        printf("product Mould productA\n");
    }
};

//模具产品B类
class MouldProductB  :public MouldProduct{

    //@Override
    public:
     void Show() {
        printf("product Mould productB\n");
    }
};

//创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
//A厂 - 生产模具+容器产品
class FactoryA  :public Factory{

    //@Override
    public:
     AbstractProduct* ManufactureContainer() {
        AbstractProduct *p =  new ContainerProductA();
        return p;
    }

    //@Override
    public:
     AbstractProduct* ManufactureMould() {
        AbstractProduct *p =  new MouldProductA();
        return p;
    }
};

//B厂 - 生产模具+容器产品
class FactoryB  :public Factory{

    //@Override
    public:
     AbstractProduct* ManufactureContainer() {
        AbstractProduct *p =  new ContainerProductB();
        return p;
    }

    //@Override
    public:
     AbstractProduct* ManufactureMould() {
        AbstractProduct *p =  new MouldProductB();
        return p;
    }
};

//生产工作流程

//生产工作流程
class AbstractFactoryPattern {
    public:
    static void main1(){
        FactoryA* mFactoryA = new FactoryA();
        FactoryB* mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA->ManufactureContainer()->Show();
        //A厂当地客户需要模具产品A
        mFactoryA->ManufactureMould()->Show();

        //B厂当地客户需要容器产品B
        mFactoryB->ManufactureContainer()->Show();
        //B厂当地客户需要模具产品B
        mFactoryB->ManufactureMould()->Show();

    }
};



int main()
{
    AbstractFactoryPattern::main1();
	return 0;
}

运行结果：

product container productA
product Mould productA
product container productB
product Mould productB