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