设计模式——AbstractFactory

上一篇我们提到，可以用工厂模式（Factory Pattern）实现一个类族的对象创建问题，但是对于不同的类，对象创建就需要抽象工厂模式（AbstractFactory Pattern）了。

---

抽象工厂模式的定义为：提供一个创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。

抽象工厂模式的实现为：将这一组对象的创建封装到一个用于创建对象的类，仅需要维护一个这样的创建类。

还是用一个具体的例子来解释。

我们将创建两个类，Shape和Color，定义Shape的draw()方法为虚函数，然后通过子类Circle和Square来实现，同理，定义Color的fill()方法为虚函数，然后通过子类Red和Green来实现。

class Shape
{
    public:
        Shape();
        virtual void draw(){};
};

class Circle : public Shape
{
    public:
        Circle();
        void draw();
};

class Square : public Shape
{
    public:
        Square();
        void draw();
};

void Circle::draw()
{
    cout<<"draw a circle"<<endl;
}

void Square::draw()
{
    cout<<"draw a square"<<endl;
}


class Color
{
    public:
        Color();
        virtual void fill(){};
};

class Red : public Color
{
    public:
        Red();
        void fill();
};

class Green : public Color
{
    public:
        Green();
        void fill();
};

void Red::fill()
{
    cout<<"fill with red"<<endl;
}

void Green::fill()
{
    cout<<"fill with green"<<endl;
}

然后我们定义一个抽象工厂类AbstractFactory，在里面去分别定义两个类的创建对象的方法。

enum shapetype
{
    CIRCLE,
    SQUARE
};

enum colortype
{
    RED,
    GREEN
};

class AbstractFactory
{
    public:
        virtual Shape *createShape(enum shapetype type);
        virtual Color *createColor(enum colortype type);
};

Shape *AbstractFactory::createShape(enum shapetype type)
{
    cout<<"createShape in AbstractFactory"<<endl;
    if(type == CIRCLE)
        return new Circle();
    if(type == SQUARE)
        return