【设计模式】创建型模式之抽象工厂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

代码如下:

/*
 * @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 PhoneFactory
 */
class PhoneFactory
{
public:
    PhoneFactory();
    virtual Glass* createGlass();
    virtual Camera* createCamera();
};

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

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

/*
 * @class MakePhone
 */
class MakePhone
{
public:
    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");
}

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

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

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

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

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

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

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

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

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

/* MakePhone */
MakePhone::MakePhone(PhoneFactory *phone)
{
    if (phone) {
        Glass *glass = phone->createGlass();
        std::cout << glass->glassType() << std::endl;
        Camera *camera = phone->createCamera();
        std::cout << camera->cameraType() << std::endl;
    }
}

测试代码如下:

    IPhoneFactory iphone;
    MakePhone myPhone(&iphone);

    NexusFactory nexus;
    MakePhone myPhone2(&nexus);

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

时间: 05-10

【设计模式】创建型模式之抽象工厂Abstract Factory的相关文章

【C#设计模式——创建型模式】抽象工厂模式

抽象工厂模式比工厂模式具有更高层次的抽象性.当要返回一系列相关类中的某一个,而每个类都能根据需要返回不同的对象时,可以选择这种模式.直接进入示例. 示例描述:完成花园的规划,多种花园种类,每个里面多种植物 编写一个基类Garden,Garden就是抽象工厂.它定义了具体类中的方法,并返回一系列相关类中的某个类. public class Garden { protected Plant center, shade, border; protected bool showCenter, showS

一起来学设计模式-----创建型模式之简单工厂

一直都特别想整体学习下设计模式,之前总觉得不是时候,觉得基础不够好怕吸收不了,或者体会不到设计模式带来的便利.就在上半年的KPI编写测试桩项目中,我就深刻的感受到设计模式带来的好处.一般测试人员写的代码不是很多,很多时候写代码也都是基于解决问题的逻辑来的,写的代码面向过程思路较多,因此代码的冗余度特别大.在编写一个大的测试工具时,就更应该考虑这方面的问题自己是否存在.刻不容缓的学习起了设计模式,整理就从创建型模式的工厂模式开始入手吧. 创建型模式,共三种:工厂方法模式.建造者模式.原型模式.其中

工厂模式[3] 抽象工厂 Abstract Factory

简介 1.简单工厂,或静态工厂,产品接口 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类或实现同一接口 优点:客户端可以直接消费产品,而不必关心具体产品的实现(不关心对象的构造方法是怎么new的),消除了客户端直接创建产品对象的责任,实现了对责任的分割. 缺点:工厂类记录了所有产品的创建逻辑,一旦不能正常工作,整个系统都会受到影响:而且当产品种类多.结构复杂的时候,把所有创建工作放进一个工厂中来,会使后期程序的扩展较为困难. 2.工厂方法,工厂接口+产品接口 定义:在

设计模式(三) : 创建型模式--工厂方法模式

工厂方法模式区别与简单工厂模式主要在于,factory中对对象的实例化延迟到了子类的factory中, 这也是优于简单工厂的地方.下面看这个模式的类图(截自<java与模式>): 示意性代码: ? 1 2 3 4 5 6 7 package com.javadesignpattern.factorymethod; public interface Creator {          public Product fatcory(); } package com.javadesignpatte

JDK 源码 阅读 - 2 - 设计模式 - 创建型模式

A.创建型模式 抽象工厂(Abstract Factory) javax.xml.parsers.DocumentBuilderFactory DocumentBuilderFactory通过FactoryFinder实例化具体的Factory. 使用例子: DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder docBuilder = docBuilder

设计模式——创建型模式

简单的说我们可以把23种设计模式可以归为三大类,分别是创建型模式.结构型模式和行为型模式. 今天,首先看一下创建型模式.创建型设计模式包括5种:单例模式(Singleton).工厂方法模式(Factory Method).抽象工厂模式(Abstract Factory).建造者模式(Builder).原型模式(Prototype).  1.单例模式(Singleton)        1)简介 保证一个类仅有一个实例,并提供一个访问它的全局访问点. 单例模式是一种常用的软件设计模式.在它的核心结

C#设计模式-创建型模式(转)

一.简单工厂模式 简单工厂模式Simple Factory,又称静态工厂方法模式.它是类的创建模式.是由一个工厂对象决定创建出哪一种产品类的实例,是不同的工厂方法模式的一个特殊实现. 优点: u 模式的核心是工厂类,该类中含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的责任,而仅仅负责"消费"产品. u 简单工厂模式实现了对责任的分割. 缺点: u 当产品类有复杂的多层次等级结构时,工厂类只有它自己.以不变应万变. u 模式中工厂类集中了所

设计模式&mdash;&mdash;创建型模式

解决问题:创建对象,将创建对象的任务交给另一个对象完成. 组成: 简单工厂:客户传递创建产品的类型到工厂类中去,工厂类根据类型实例化不同的类. 工厂方法Factory Method:定义一个用户创建对象的接口,让子类决定实例化哪一个类.                           优点:客服了简单工厂违背开放封闭原则的缺点. 抽象工厂Abstract Factory:提供一个创建一系列或相关依赖对象的接口,而无需指定它们具体的类.                           优点

java设计模式--创建型模式

2016-04-24 10:10:34 创建型模式:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式 注意:工厂模式可以分为三类: 1)简单工厂模式(Simple Factory) 2)工厂方法模式(Factory Method) 3)抽象工厂模式(Abstract Factory)  这三种模式从上到下逐步抽象,并且更具一般性.GOF在<设计模式>一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory).将简单工厂模式