Creational Patterns

Main points

Abstract the instantiation process.
Provide independence of objects creation, composition and representation.
Are useful for systems depending more on composition than inheritance.
Use a small set of fundamental behaviors that can be composed into several more complex behaviors, rather than hardcoding a fixed set of behaviors.
Create objects that require more than simply instantiating a class.

Recurring themes

Encapsulate knowledge about concrete classes used by a client.
Hide to the client how objects are created and assembled. Client only knows object interfaces
Control what, who, how and when an object is created.
Allow dynamic and static configuration of a client.

Code sketches

The following pseudo-code fragments try to highlight the distinguishing features of 4 patterns that, for some purposes, are interchangeable. The goal is synthesis and comparison, not completeness and precision.

FactoryMethod

FactoryMethodIF {               // an abstract class
  createProduct1 ()             // abstract or near empty
  createProduct2 ()             // abstract or near empty
  final creator () {            // create products
    createProduct1 ()
    createProduct2 ()
  }
}

Factory_A extends FactoryMethodIF {   // a concrete class
  createProduct1 ()                   // specialized
  createProduct2 ()                   // specialized
}

FactoryMethodIF factory = new Factory_A ()
factory.creator ()

AbstractFactory

AbstractFactoryIF {           // an interface or abstract class
  createProduct1 ()           // abstract
  createProduct2 ()           // abstract
}

Factory_A implements AbstractFactoryIF {  // a concrete class
  createProduct1 ()                       // specialized
  createProduct2 ()                       // specialized
}

AbstractFactoryIF factory = new Factory_A ()
factory.createProduct1 ()     // compose with other products
factory.createProduct2 ()     // compose with other products

Builder


BuilderIF {                       // an interface or abstract class
  static getInstance (type)       // get Concrete Builder
  createProduct1 ()               // abstract
  createProduct2 ()               // abstract
}

Builder_A extends BuilderIF {             // a concrete class
  createProduct1 ()                       // specialized
  createProduct2 ()                       // specialized
}

BuilderIF builder = BuilderIF.getInstance (type_of_A)
builder.createProduct1 ()         // possibly via "director"
builder.createProduct2 ()         // possibly via "director"

Prototype

Prototype {
  Prototype (prototypes)
  Product1                            // to be cloned
  Product2                            // to be cloned
  createProduct1 ()
  createProduct2 ()
}

Prototype prototype = new Prototype (prototypes)    // initialize
prototype.createProduct1 ()
prototype.createProduct2 ()

Last updated: Mon Jan 17 09:44:25 PST 2000