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

叁歲伎倆 2022-08-22 00:15 205阅读 0赞

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

![这里写图片描述][20160508182930653]

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

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在创建手机时，使用的是抽象工厂、抽象产品类，并不知道具体的实现类的细节，这便是抽象工厂设计模式的目的，分离了具体的实现类，使用了虚函数及类型自动向上转化的特点，即子类类型自动转为父类类型。

[20160508182930653]: /images/20220724/6c76ed4e2f854cc1b437bd06feb47c3a.png