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