设计模式之十一：抽象工厂模式(Abstract Factory)

抽象工厂模式：

提供了一个创建一系列相关的或相互依赖的对象的接口而不须要详细指定它们的类型。

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

UML类图：

主要包含：

1. AbstractFactory(ContinentFactory)：抽象的工厂类。为详细的工厂类声明了一系列的接口。
2. ConcreteFactory(AfricaFactory，AmericaFactory)：详细的工厂类。实现了创建详细对象的接口。
3. AbstractProduct(Herbivore,Carnivore)：抽象的产品类。

4. Product(Wildebeest,Lion,Bison,Wolf)：详细的产品类
5. Client(AnimalWorld)：使用抽象的工厂和抽象的产品类来创建对象。

主要的抽象工厂模式C++代码例如以下：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>

class AbstractProductA
{
    public:
            virtual void show()=0;
};

class  ProductA1:public AbstractProductA
{
    public:
            void show()
            {
                std::cout<<"ProductA1::show()"<<std::endl;
            }

};

class  ProductA2:public AbstractProductA
{
    public:
            void show()
            {
                std::cout<<"ProductA2::show()"<<std::endl;
            }
};

class AbstractProductB
{
    public :
            virtual void display()=0;
};

class ProductB1:public AbstractProductB
{
    public:
            void display()
            {
                std::cout<<"ProductB1::display()"<<std::endl;
            }
};

class ProductB2:public AbstractProductB
{
    public:
            void display()
            {
                std::cout<<"ProductB2::display()"<<std::endl;
            }
};

class AbstractFactory
{
        public:
                virtual AbstractProductA* createProductA()=0;
                virtual AbstractProductB* createProductB()=0;

};

class ConcreteFactory1:public AbstractFactory
{
        public:
                AbstractProductA *createProductA()
                {
                    return new ProductA1();
                }
                AbstractProductB *createProductB()
                {
                    return new ProductB1();
                }
};

class ConcreteFactory2:public AbstractFactory
{
        public:
                AbstractProductA *createProductA()
                {
                    return new ProductA2();
                }
                AbstractProductB *createProductB()
                {
                    return new ProductB2();
                }
};

class Client
{
    public:

    Client()
    {
    }
    Client(AbstractFactory *af)
    {
        abstractFactory=af;
    }
    AbstractProductA * getProductA()
    {
        return abstractProductA;
    }
    AbstractProductB* getProductB()
    {
        return abstractProductB;
    }

    void run()
    {
        abstractProductA=abstractFactory->createProductA();
        abstractProductB=abstractFactory->createProductB();
    }
    ~Client()
    {
        if(!abstractProductA)
                delete abstractProductA;
        if(!abstractProductB)
                delete abstractProductB;
    }

    private:
    AbstractFactory *abstractFactory;
    AbstractProductA * abstractProductA;
    AbstractProductB * abstractProductB;
};

int main()
{
    std::cout<<"抽象工厂模式測试"<<std::endl;
    AbstractFactory *af=new ConcreteFactory1();
    Client* client=new Client(af);

    client->run();
    client->getProductA()->show();
    client->getProductB()->display();

    delete af;
    delete client;
    return 0;
}

运行结果：

再看一个详细的样例:

1. AbstractFactor为ContinentFactory，即大陆工厂。

2. ConcreteFactory为AfricaFactory（非洲大陆），AmericaFacoty（美洲大陆）
3. AbstractProduct包含Herbivore（食草动物）。Carnivore（食肉动物）。
4. Product包含Wildebeest（羚羊），Lison(狮子)。Bison（美洲野牛），Wolf（美洲狐狸）。
5. Client为AnimalWorld。

大陆上有食肉动物和食草动物，可是不同的大陆比方说非洲大陆的食肉动物和食草动物和美洲大陆的食肉动物和食草动物是不同的。抽象工厂工厂模式和工厂方法模式的不同点就在于抽象工厂模式有两处变化的地方，除了工厂类能够变化外，抽象的产品类有多个而不是一个。

UML图例如以下：

C++代码实现例如以下：

#include <stdlib.h>
#include <stdio.h>
#include <iostream>

//食草动物
class Herbivore
{
        public:
                virtual void drink()=0;
};

//羚羊的一种。产于非洲
class Wildebeest:public Herbivore
{
        public:
                void drink()
                {
                    std::cout<<"wildbeest drink"<<std::endl;
                }
};

//美洲野牛
class Bison:public Herbivore
{
        public:
                void drink()
                {
                    std::cout<<"bison drink"<<std::endl;
                }
};

//食肉动物
class Carnivore
{
    public:
            virtual void eat()=0;
};

//非洲狮子
class Lion:public Carnivore
{
    public:
            void eat()
            {
                std::cout<<"lion eat"<<std::endl;
            }
};

//狼
class Wolf:public Carnivore
{
        public:
            void eat()
            {
                std::cout<<"wolf eat"<<std::endl;
            }
};

//大陆工厂
class ContinentFactory
{
        public:
                virtual Herbivore * createHerbivore()=0;
                virtual Carnivore * createCarnivore()=0;

};

class AfricaFactory :public ContinentFactory
{
        public:
                virtual Herbivore * createHerbivore()
                {
                    return new Wildebeest();
                }
                virtual Carnivore * createCarnivore()
                {
                    return new Lion();
                }

};

class AmericaFactory :public ContinentFactory
{
        public:
                virtual Herbivore * createHerbivore()
                {
                    return new Bison();
                }
                virtual Carnivore * createCarnivore()
                {
                    return new Wolf();
                }

};

class AnimalWorld
{
        public:
                AnimalWorld()
                {

                }
                AnimalWorld(ContinentFactory *cf)
                {
                        herbivore=cf->createHerbivore();
                        carnivore=cf->createCarnivore();

                }
                void action()
                {
                        herbivore->drink();
                        carnivore->eat();
                }
                ~AnimalWorld()
                {
                        if(!herbivore)
                                delete herbivore;
                        if(!carnivore)
                                delete carnivore;
                }
        private:
                Herbivore * herbivore;
                Carnivore * carnivore;

};

int main()
{
    std::cout<<"抽象工厂模式详细的样例"<<std::endl;
    ContinentFactory * cf=new AmericaFactory;
    AnimalWorld *an=new AnimalWorld(cf);
    an->action();
    delete cf;
    delete an;
    return 0;
}

运行结果：