Æliens

factory

provide interface for creating family of related or dependent objects without specifying their concrete classes

Example

also known as kit

participants

• AbstractFactory, Concrete Factory, Abstract Product, Concrete Product

consequences

• isolate concrete classes
• makes exchanging product families easy
• promotes consistency among products
• supporting new kinds of products is difficult

implementation

See GOF

factory method

define interface for creating an object, but let subclass decide which class to instantiate

also know as

virtual constructor

motivation

• encapsulates knowledge of which subclass to instantiate

applicability

• when a class can not anticpate the class of the objects it creates
• to delegate responsibility of object creation

structure

participants

• Product, ConcreteProduct, Creator, ConcreteCreator

consequences

• provide hooks for subclasses
• connects parallel class hierarchies

related

• Factory, Prototype

singleton

ensure a class has only one instance and provide a global point of access

applicability

• only one instance of a class
• instance must be extendable by subclassing

implementation

     // .h file 
  
     class Singleton {
     public:
  	static Singleton instance();
     protected: 
 limit access
  	Singleton();
     private:
  	static Singleton* _instance;
     };
  
  
     // .c file
  
     Singleton* Singleton::_instance = 0;
  
     Singleton* Singleton::instance() {
  	if (_instance == 0)
  		_instance = new Singleton();
  	return _instance;
  	}
  

consequences

• coordinate access to a single instance
• reduced namespace
• permit refinement
• permit variable number of instances

etcetera

see GOF

prototype

specify kinds of objects to create using a prototypical instance and create by copying this prototype

motivation

• flexibility, reduce number of classes

applicability

• when classes to instantiate are specified at runtime
• to avoid building a class hierarchy of factories
• to reduce static dependencies

participants

• Prototype, ConcretePrototype, Client

consequences

• adding and removing product types at runtime
• specifying new objects by varying value/structure
• reduced subclassing
• configure an application with classes dynamically see kit.h and dv/tk/kit.c

related

• AbstractFactory versus Prototype