Creational Patterns

CSE301

University of Sunderland

Harry R Erwin, PhD

Pattern Languages

• Alexander (1977) invented the idea of a pattern language as a practical tool for describing architectural expertise in some domain.

• The elements of a pattern language are patterns. Each pattern describes a problem that occurs over and over again, and then describes the core of the solution to that problem in such a way that it can be reused many times, never once doing it the same way.

• A pattern isn’t considered proven until it has been used at least three times in real applications.

Design Patterns

• The four essential elements (Gamma, et al) of a design pattern are:– A descriptive name – A problem description that shows when to apply the

pattern and to what contexts. The description explains how it helps to complete larger patterns.

– A solution that abstractly describes the constituent elements, their relationships, responsibilities, and collaborations.

– The results and trade-offs that should be taken into account when applying the pattern.

Resources

• Gamma, Helm, Johnson, and Vlissides, 1995, Design Patterns, Addison-Wesley.

• Cooper, 1998, The Design Patterns Java Companion, Addison-Wesley, available free from http://www.patterndepot.com/put/8/JavaPatterns.htm,the sample code in the book is available as http://www.patterndepot.com/put/8/JavaPatterns.ZIP.

• The Portland Pattern Repository: http://c2.com/ppr/• Alexander, 1977, A Pattern Language: Towns/Buildings/

Construction, Oxford University Press. (For historical interest.)

Some Creational Patterns

• Builder

• Factory Method

• Abstract Factory

• Prototype

• Singleton

Builder• Ever need to build a complex object in a specified way from

different concrete classes? E.g., an airplane has wings, tail, fuselage, engines, landing gear, etc., all selected from families of components.

• The Builder class is an abstract interface for a construction process that puts together a system of a specific type.

• Positives:– Encapsulation– Code isolation– Fine control over the build process

• Negatives:– Only certain types of composite objects lend themselves to a build

process. And don’t build a whale using the build process for a bird.

Factory Method

• You need an object, but which subtype of the object needs to be decided later. This can be a particularly problem during initialization, as it means the file/object loader has to know every possible subclass.

• The solution to this is called the ‘factory method’ or ‘object factory’.

• Positives:– Flexibility– Can connect parallel class hierarchies

• Negatives:– Forces subclassing of the base class

Abstract Factory• Ever need to provide a family of related or dependent objects,

where the underlying concrete classes need to be specified based on implementation details not of concern to the using program?

• The pattern that does this is called an ‘abstract factory’. We will discuss Modified Visual Proxy in Lecture 19.

• Positives: – Enforces encapsulation– Makes exchanging families easy– Produces consistency

• Negatives:– Adding new families is difficult. Each family needs a concrete factory

implementing the AbstractFactory. If many factors must be considered, there can be an explosion in the amount of code.

Prototype• Uses clone() rather than new to create objects. You can specialize a

prototype object at program start-up to address implementation issues that cannot be specified at compile time.

• Positives:– Allows you to bind design details at run-time.– Allows you to define a pseudo-subclass at run-time parameterized or indexed by a

numeric value.– Allows you to duplicate object data if a large set of objects need to be defined with

common characteristics.– Avoids excessive subclassing. – Allows you to do dynamic loading of classes.

• Negatives:– Everything needs to implement clone().– Designing this approach into a class is highly non-trivial.

Singleton• Ensures a class has a globally accessible unique instance.• Sometimes you need a class with only one instance, and sometimes

you need global access to a class. • Positives:

– Avoids the need to link objects at system initialization.– Sometimes you need it badly.– Supports persistence. The local copy can be a proxy for a copy kept on disk.– Reduced name space pollution.– Can be modified to support multiple instances using a Map.

• Negatives:– Has to be carefully implemented.– Sometimes it’s just not useful.

Examples from Book