【设计模式】创建型模式之抽象工厂Abstract Factory

抽象工厂Abstract Factory是一种创建型设计模式，目的在于提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂的类图如下，客户仅与抽象类定义的定义的接口交互，而不使用特定的具体类的接口。一个系统包含多种产品时，AbstractFactory声明创建各种抽象产品对象的操作接口，这些接口是直接暴露给Client的，而具体产品对象的创建则延迟到子类ConcreteFactory，Client面对的产品类是AbstractProduct，无需关系具体产品类是什么。在运行时刻，为创建不同的产品对象，客户应使用不同的具体工厂，创建ConcreteFactory类的实例，具体工厂负责创建特定的产品对象。

以一个例子说明抽象工厂的用法，与上面类图的对应关系如下：

AbstractFactory——PhoneFactory
AbstractFactory::createProductA——PhoneFactory::createGlass
AbstractFactory::createProductB——PhoneFactory::createCamera
ConcreteFactory1——IPhoneFactory
ConcreteFactory1::createProductA——IPhoneFactory::createGlass
ConcreteFactory1::createProductB——IPhoneFactory::createCamera
ConcreteFactory2——NexusFactory
ConcreteFactory2::createProductA——NexusFactory::createGlass
ConcreteFactory2::createProductB——NexusFactory::createCamera
AbstractProductA——Glass
ProductA1——IPhoneGlass
ProductA2——NexusGlass
AbstractProductB——Camera
ProductB1——IPhoneCamera
ProductB2——NexusCamera
Client——MakePhone

另外，例子中还有一款产品Phone，并没有像Glass与Camera那样作为基类来使用，而是一个一般的类，这是抽象产品的具类表现，对应的抽象工厂与具体工厂也有createPhone接口。

代码如下：

/*
 * @class Glass
 */
class Glass
{
public:
    Glass();
    virtual std::string glassType() const;
};

/*
 * @class IPhoneGlass
 */
class IPhoneGlass : public Glass
{
public:
    IPhoneGlass();
    std::string glassType() const;
};

/*
 * @class NexusGlass
 */
class NexusGlass : public Glass
{
public:
    NexusGlass();
    std::string glassType() const;
};

/*
 * @class Camera
 */
class Camera
{
public:
    Camera();
    virtual std::string cameraType() const;
};

/*
 * @class IPhoneCamera
 */
class IPhoneCamera : public Camera
{
public:
    IPhoneCamera();
    std::string cameraType() const;
};

/*
 * @class NexusCamera
 */
class NexusCamera : public Camera
{
public:
    NexusCamera();
    std::string cameraType() const;
};

/*
 * @class Phone
 */
class Phone
{
public:
    Phone();
    void addGlass(Glass *glass);
    Glass* getGlass();
    void addCamera(Camera *camera);
    Camera* getCamera();

private:
    Glass *m_glass;
    Camera *m_camera;
};

/*
 * @class PhoneFactory
 */
class PhoneFactory
{
public:
    PhoneFactory();
    virtual Phone* createPhone();
    virtual Glass* createGlass();
    virtual Camera* createCamera();
};

/*
 * @class IPhoneFactory
 */
class IPhoneFactory : public PhoneFactory
{
public:
    IPhoneFactory();
    Phone* createPhone();
    Glass* createGlass();
    Camera* createCamera();
};

/*
 * @class NexusFactory
 */
class NexusFactory : public PhoneFactory
{
public:
    NexusFactory();
    Phone* createPhone();
    Glass* createGlass();
    Camera* createCamera();
};

/*
 * @class Client
 */
class Client
{
public:
    Client();
    Phone* makePhone(PhoneFactory *phone);
};

/* Glass */
Glass::Glass()
{
}

std::string Glass::glassType() const
{
    return std::string("Unknown Glass");
}

/* IPhoneGlass */
IPhoneGlass::IPhoneGlass()
{
}

std::string IPhoneGlass::glassType() const
{
    return std::string("IPhone Glass");
}

/* NexusGlass */
NexusGlass::NexusGlass()
{
}

std::string NexusGlass::glassType() const
{
    return std::string("Nexus Glass");
}

/* Camera */
Camera::Camera()
{
}

std::string Camera::cameraType() const
{
    return std::string("Unknown Camera");
}

/* IPhoneCamera */
IPhoneCamera::IPhoneCamera()
{
}

std::string IPhoneCamera::cameraType() const
{
    return std::string("IPhone Camera");
}

/* NexusCamera */
NexusCamera::NexusCamera()
{
}

std::string NexusCamera::cameraType() const
{
    return std::string("Nexus Camera");
}

/* Phone */
Phone::Phone()
    : m_glass(0)
    , m_camera(0)
{
}

void Phone::addGlass(Glass *glass)
{
    m_glass = glass;
}

Glass* Phone::getGlass()
{
    return m_glass;
}

void Phone::addCamera(Camera *camera)
{
    m_camera = camera;
}

Camera* Phone::getCamera()
{
    return m_camera;
}

/* PhoneFactory */
PhoneFactory::PhoneFactory()
{
}

Phone* PhoneFactory::createPhone()
{
    return 0;
}

Glass* PhoneFactory::createGlass()
{
    return 0;
}

Camera* PhoneFactory::createCamera()
{
    return 0;
}

/* IPhoneFactory */
IPhoneFactory::IPhoneFactory()
{
}

Phone* IPhoneFactory::createPhone()
{
    return new Phone;
}

Glass* IPhoneFactory::createGlass()
{
    return new IPhoneGlass;
}

Camera* IPhoneFactory::createCamera()
{
    return new IPhoneCamera;
}

/* NexusFactory */
NexusFactory::NexusFactory()
{
}

Phone* NexusFactory::createPhone()
{
    return new Phone;
}

Glass* NexusFactory::createGlass()
{
    return new NexusGlass;
}

Camera* NexusFactory::createCamera()
{
    return new NexusCamera;
}

/* Client */
Client::Client()
{
}

Phone* Client::makePhone(PhoneFactory *phone)
{
    if (phone) {
        Phone *myPhone = phone->createPhone();
        Glass *glass = phone->createGlass();
        Camera *camera = phone->createCamera();
        myPhone->addGlass(glass);
        myPhone->addCamera(camera);
        std::cout << myPhone->getGlass()->glassType() << std::endl;
        std::cout << myPhone->getCamera()->cameraType() << std::endl;

        return myPhone;
    }
    return 0;
}

测试代码如下：

    IPhoneFactory iphone;
    Client client;
    client.makePhone(&iphone);

    NexusFactory nexus;
    Client client2;
    client2.makePhone(&nexus);

例子中，Client使用一个AbstractFactory作为参数来创建手机，为了创建不同类型的手机，需要使用AbstractFactory的子类的对象作为参数，即IPhoneFactory或者NexusFactory，手机类型为IPhone或者Nexus，首先创建手机Phone，然后创建各自的零部件Glass和Camera，它们的类型与其手机的类型相符，glassType和cameraType函数可以验证我们的零部件类型是否正确。可以看出，makePhone在创建手机时，使用的是抽象工厂、抽象产品类，并不知道具体的实现类的细节，这便是抽象工厂设计模式的目的，分离了具体的实现类，使用了虚函数及类型自动向上转化的特点，即子类类型自动转为父类类型。