Design Pattern ->Abstract Factory

　　　　　　　　　　　　_{^{Layering & Contract Philosophy With additional indirection}}

Abstract Factory

 //The example code is as following:

 class CAbstractProductA;

 class CAbstractProductB;

 // multiple families of products.

 class CProductA1:public CAbstractProductA;

 class CProductB1:public CAbstractProductB;

 class CProductA2:public CAbstractProductA;

 class CProductB2:public CAbstractProductB;

 class CAbstractFactory

 {

 public:

     virtual CAbstractProductA* CreateProductA() = ;

     virtual CAbstractProductA* CreateProductB() = ;

 };

 class CConreateFactory1:public CAbstractFactory;  //indirection layer

 {

 public:

     virtual CAbstractProductA* CreateProductA() { return new CProductA1; }

     virtual CAbstractProductB* CreateProductB() { return new CProductB1; }

 }

 class CConreateFactory2:public CAbstractFactory;//indirection layer

 {

 public:

     virtual CAbstractProductA* CreateProductA() { return new CProductA2; }

     virtual CAbstractProductB* CreateProductB() { return new CProductB2; }

 }

 class CClient

 {

 public:

     CAbstractFactory  *pFactory = NULL;

     void main()

     {

            if ( the system is windows )
              {

                    pFactory  = new CConreateFactory1();
              }

            else
              {

                   pFactory  = new CConreateFactory2();

             }

        CAbstractProductA *pProductA = pFactory->CreateProductA();

        CAbstractProductB *pProductB = pFactory->CreateProductB();

      }

 };

Applicability
Use the Abstract Factory pattern when:

A system should be independent of how its products are created, compose /decompose, and represented.
A system should be configured with one of multiple families of products.
A family of related product objects is designed to be used together, and you need to enforce this constraint.
You want to provide a class library of products, and you want to reveal just their interfaces, not their implementations. Interface-Oriented programming, Open For Extension, Close For Change，These All is said to Users or Client. Users don’t care or never know what is changed, so called “Close For Change”.
You want to create a set of product without changing client code. Just create a new pointer to the object instantiated with class derived from base class AbstractClass.

Participants

AbstractFactory (WidgetFactory): declares an interface for operations that create abstract product objects.
ConcreteFactory (MotifWidgetFactory, PMWidgetFactory):implements the operations to create concrete product objects.
AbstractProduct (Window, ScrollBar):declares an interface for a type of product object.
ConcreteProduct (MotifWindow, MotifScrollBar): concrete / specific defines a product object to be created by the corresponding concrete factory,implements the AbstractProduct interface.
Client: uses only interfaces declared by AbstractFactory and AbstractProduct classes.

Collaborations

Normally a single instance of a ConcreteFactory class is created at run-time.This concrete factory creates product objects having a particular implementation. To create different product objects, clients should use a different concrete factory.The Client get the a pointer or reference from the Singleton object created with ConcreteFactory at run-time.
AbstractFactory defers creation of product objects to its ConcreteFactory subclass.

From:Design Patterns:Elements of Reusable Object-Oriented Software, by GoF

巴特西

Design Pattern ->Abstract Factory

最新文章

热门文章