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() = 0;
    virtual CAbstractProductA* CreateProductB() = 0;
};
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