设计模式-抽象工厂。

 

#   抽象工厂 

   工厂模式中具体工厂负责具体产品，每一个具体工厂对应一个具体产品，工厂方法具有唯一性。有时候需要一个工厂提供多个产品对象，而不是单一的产品对象。
   引入两个概念、
*    产品等级结构
    产品等级结构即产品的继承结构、如抽象类是电视机，子类有黑色电视机、白色电视机。
*     产品族
    在抽象工厂模式内，产品族是同一个工厂生产的，位于不同产品等级结构的一组产品。
    如黑色冰箱，白色冰箱。
当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率
        
定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类，抽象工厂模式又称kit模式，属于对象创建型模式。

伪代码1
AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
Product：具体产品
#include <iostream>
#include "AbstractFactory.h"
#include "AbstractProductA.h"
#include "AbstractProductB.h"
#include "ConcreteFactory1.h"
#include "ConcreteFactory2.h"

using namespace std;
int main (int argc, char* argv[])
{
    AbstractFactory *fc = new ConcreteFactory1();
    //创建一个具体工厂，进行生产
    
    //具体工厂fc生产产品A 、同时生产产品B
    一个工厂完成两个产品的生产。
    AbstractProductA *pa = fc->createProductA();
    AbstractProductB *pb = fc->createProductB();
    pa->use();
    pb->eat();
    
   AbstractFactory* fc2 = new ConcreteFactory2();
   AbstractProductA* pa2 = fc2->createProductA();
   AbstractProductB* pb2 = fc2->createProductB();
   pb2->use();
   pa2->eat();
   
}

#include "ConcreteFactory1.h"
#include "ProductA1.h"
#include "PorductB1.h"
AbstractProductA * ConcreteFactory1::createProductA(){
    return new ProductA1();
}
AbstractProductB * ConcreteFactory2::createProductB(){
    return new ProductB1();
}
#include "ProductA1.h"
#include <iostream>
using namespace std;
void ProductA1:use(){
cout << "use productA1" << endl;
}

伪代码2 
AbstractFactory.h
#ifndef _ABSTRACT_FACTORY_
#define _ABSTRACT_FACTORY_
#include <iostream>
#include <string.h>
using namespace std;
//抽象产品
class AbstractBall
    {
        public:
        AbstractBall(){}
        virtual ~AbstractBall(){}
        virtural void paly(){};
    };
//具体产品BasketBall
class Basketball:public AbstractBall
{
    public:
        Basketball(){
            play();
        }
        void paly(){
        printf("xxxxxxxx  basketball\n");
        }
};

//抽象产品类AbstracShirt
class AbstractShirt
{
    public:
    virtual ~AbstractShirt(){}
    virtual void WearShirt(){};
};

//具体产品类BasketBallShirt  衍生的具体产品数量是可以灵活增加的。
class BasketBallShirt: public AbstractShirt
{
    public:
    BasketBallShirt(){
    WearShirt();
    }
    void WearShirt(){
    printf("xxx basketball shirt");
    }
}

以上是两个抽象产品，衍生2个具体产品。

//抽象工厂
//工厂返回值，应该为产品，返回值类型为抽象，

class AbstractFactory{
    //标明工厂既可以生产 产品类球 和产品类衣服
    virtual ~AbstractFactory(){}
    virtual  AbstractBall* getBall() = 0;
    virtual  AbstractShirt* getShirt() = 0;
}

//具体工厂 可以灵活增加工厂来定制化生产多个抽象产品类的具体产品
class BasketballFactory :public AbstractFactory{
    public:
    BasketballFactory(){
        printf(" basketball Factory\n");
    }
    AbstractBall * getBall(){
        printf("get baskey ball");
        return new Basketball(); //返回具体产品 由抽象产品类型进行承接。
    }
    AbstractShirt * getShirt(){
        printf("get basket ball shirt ");
        return new BasketBallShirt(); //返回具体产品 由抽象产品类型进行承接。
    }
    
}