TUTORIAL ON DESIGN PATTERNS



Should You take this tutorial?
For some lucky people, design patterns are obvious tools and they grasp
their essential utility just by reading the summaries or intents of patterns. 
For the rest of us, there is a slow induction period after we’ve read about 
a pattern followed by the proverbial “Aha!” when we see how we can apply them
in our work. 
If you fall under the latter of the two categories and want to learn about 
design patterns as a means of improving your object-oriented design and 
development skills then you best continue reading.

This tutorial assumes that you are familiar with an object oriented language 
such as Java and basic oops concepts such as polymorphism, inheritance and 
encapsulation.

Check out the SCEA resources section for links to some of the 
free books and other resources on design patterns.




**********PART 1: FUNDAS FROM THE GANG OF FOUR**********


Part 2  

FUNDA NO 1: Program to an Interface and not an Implementation.
Implementation reuse (i.e. Class Inheritance) is basically a mechanism
for extending an applications functionality by reusing functionality 
defined in the parent class.
Inheriting from an abstract base class is also important.
WHY? Because polymorphism depends on it...

Basically what that means is, you should define the top of any class 
hierarchy with an abstract class, which simply defines the methods that
class will support. Then, in all of your derived classes you have more 
freedom to implement these methods as most suits your purposes.

The two main benifits from this approach are:-

(Polymorphism) - Clients remain unaware of the specific types of 
objects they use, as long as the objects adhere to the interface/type
the clients expect.

(Isolation) - Clients remain unaware of the classes that implement these
objects. Clients only know about the abstract classes/interfaces.

Creational Patterns ensure that your system is written in terms of 
interfaces and not implementations.
This greatly reduces implementation dependencies between sub systems.


FUNDA NO 2: Favour Object composition over class inheritance

Object Composition allows us to extend functionality by encapsulating 
several objects inside another one. WHY favour it???
Because Inheritance breaks encapsulation and Composition doesnt..

Firstly implementation inherited from parent class cannot be changed at
runtime. Generally the sub class also becomes so tigtly bound to the
implementation of the parent class that any changes to the parent class
will force the sub class to change. This reduces sub class reusability.

Object composition is defined dynamically at runtime through objects 
acquiring references to other objects. 
Composition requires objects to respect each others interfaces.

The merits of composition become apparent when your new object can have
the interface that is best suited for what you want to accomplish
without having all the methods of the parent classes, since objects are
accessed solely through their interfaces,we dont break encapsulation.

Objects having the same type are interchangeable at runtime.
(Polymorphic)

Favouring object composition also helps keep each class encapsulated and
focussed on one task.

In summation we can say that inheritance and composition work together.
Designers and developers often overuse inheritance as a reuse technique
and designs are often made more reusable by using object composition.

Delegation - A Reuse Technique

Delegation is a way of making composition as powerful for reuse as 
inheritance.
In delegation there are two objects involved with handling a request
the recieving object delegates operations to its delegate.

The main advantage of delegation is that it makes it easy to compose
behaviors at runtime and to change the way objects are composed.
Eg. A window can become circular at runtime simply by replacing its 
rectangle instance with a circle instance, assuming that rectangle 
and circle have the same type.

Disadvantage is that delegation due to its dynamic, highly 
parameterized nature is complicated and is prone to runtime 
inefficiencies.

Some Design patterns that use delegation are State, Strategy 
and Visitor.

Parameterized Types(generics) - A Reuse Technique

Another technique for reuse is by using parameterized types. 
This technique lets you define a type without specifying all the other
types it uses. The unspecified types are supplied as parameters at 
point of use. Eg. A List class can be parameterized by the type of 
elements it contains. To declare a list of Integers you pass "Integer"
as a parameter to the List parameterized type.
Similarly to declare a String List you pass "String" as a parameter to
the List parameterized type.




**********PART 2: DESIGN PATTERNS EXPLAINED**********



What are Design Patterns 
The concept: abstracting solutions to recurring design problems.

Christopher Alexander says "Each Pattern describes a problem 
which occours again and again in our environment and then describes the 
core of the solution to that problem in such a way that you can use this 
solution a million times over, without ever doing it the same way twice."

The Gang of Four described patterns as "a solution to a 
problem in a context". These three things -- problem, solution, 
and context -- are the essence of a pattern.



 

  

   Design Pattern Classification
  
 
 

  
PURPOSE
  
PATTERN NAME
 
 

  
Creational
  
Abstract Factory
 
 

  
Factory Method
 
  

  
Builder
 
 

  
Prototype
 
 

  
Singleton
 
 

  
Structural
  
Adapter
 
Bridge
 
Composite
 
Decorator
 
Facade
 
Flyweight
 
Proxy
 

  
Behavioral
  
 
 
 
 
 
 
 
 
 


Creational Patterns
Creational patterns abstract the creational proces.

Typically, the details of the classes that are created are encapsulated
by an abstract superclass and hidden from the client class, which knows
only about the abstract class or the interface it implements. 
The specific type of the concrete class is typically unknown to the client
class... WHEW!!

Why is all this necessary you ask...
It helps make the system independent of how its objects are created, 
composed and represented.
This in turn makes your system extendable and more importantly reusable.


 

  
The Abstract Factory Pattern
 
  

  Part 1 ||
Part 2
 

Definition:

"Provide an interface for creating families of related or dependant 
objects, without specifying their concrete classes" -- The Gang of Four.

"You can use this pattern when you want to return one of
several related classes of objects, each of which can return several 
different objects on request. In other words, the Abstract Factory is a
factory object that returns one of several factories"-- James W Cooper.

"The Abstract Factory pattern is one level of abstraction higher than
the factory method pattern"

ADVANTAGES:

Abstract Factory isolates the concrete classes that are generated.
The concrete classes are hidden in the factory and are not known
to the client.

you can change or interchange these product class families freely. 

Keeps you from inadvertently using classes from different families 
of products.

Use Abstract Factory pattern when 

A system should be independant of how its products are created, 
composed and represented.

A system should be composed 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 reveal just their
interfaces and not their implementations.



 

  
The Factory Method
  

  Part 1 || 
  Part 2
 
 

Definition:

"Define an interface for creating an object, but let subclasses 
decide which class to instantiate.Factory method lets a class defer 
instantiation to subclasses"-- The Gang of Four (G.O.F.)

"A Factory pattern is one that returns an instance of one of several 
possible classes depending on the data provided to it.
Usually all of the classes it returns have a common parent class and common
methods, but each of them performs a task differently and is optimized for
different kinds of data." -- James W Cooper.

"This pattern is used when it must be decided at run time which one 
of several compatible classes is to be instantiated." -- David Gallardo 
(ibm.com/developerWorks)

Factory Method is similar to Abstract Factory but without the emphasis
on families. 

Advantages:

The factory completely abstracts the creation and initialization of the 
product from the client. Thus, as the product implementation changes 
over time, the client remains unchanged.

Use Factory pattern when

a class can't anticipate the class of objects it must create.

a class wants its subclass to specify the objects it creates

class delegates responsibility to one of several helper subclasses
and you want to localize the knowledge of which helper subclass is the 
delegate.



 

  
The Builder Pattern
  

  Part 1 || 
  Part 2
 

Definition:

"Separates the construction of a complex object from its representation, 
so that the same construction process can create different 
representations" -- The Gang of Four (G.O.F.)

"A Builder pattern is somewhat like an Abstract Factory pattern in
that both return classes made up of a number of methods and objects. 
The main difference is that while the Abstract Factory returns a family
of related classes, the Builder constructs a complex object step by step
depending on the data presented to it." -- Cooper 

Advantage:

A Builder lets you vary the internal representation of the product it
builds. It also hides the details of how the product is assembled.
Each specific builder is independent of the others and of the rest of the
program. This improves modularity and makes the addition of other
builders relatively simple.

Because each builder constructs the final product step-by-step, depending
on the data, you have more control over each final product that a Builder
constructs.

Use the Builder pattern when 

The algorithm for creating a complex object should be independent of 
the parts that make up the object and how they are represented

the construction processs must allow different representations for the 
object that is constructed.



 

  
The Prototype Pattern
  

  Part 1 || 
  Part 2
 

Definition:

"Specify the type of objects to create using a prototypical instance
and create new objects by copying/cloning this prototype" -- G.O.F.

Advantages:

Adding and removing products at runtime.Prototype lets you create new
concrete products at runtime by registering a prototypical instance
with the client. 

It greatly reduces the number of classes the system needs.


When to use Prototype

When the classes to instantiate are specified at runtime

The Protoype pattern is used when creating an instance of a class is
very time-consuming or complex in some way. Then, rather than creating
more instances, you make copies of the original instance, modifying them
as appropriate.

Prototypes can also be used whenever you need classes that differ
only slightly in the type of processing they offer.

To avoid building a class hierarchy of factories that parallels the 
class hierarchy of products.



 

  
The Singleton Pattern
  

  Part 1 || 
  Part 2
 

Definition

"Ensure a class has only one instance, and provide a global point 
of access to it" -- The Gang of Four (G.O.F.)

"The Singleton pattern, is used to encapsulate the creation of an
object in order to maintain control over it. This not only ensures that 
only one is created, but also allows lazy instantiation; that is, the 
instantiation of the object can be delayed until it is actually needed.
This is especially beneficial if the constructor needs to perform a 
costly operation, such as accessing a remote database." 
- David Gallardo (ibm.com/developerWorks)

Advantages

"The advantage of Singleton over global variables is that you are 
absolutely sure of the number of instances when you use Singleton, 
and, you can change your mind and manage any number of instances."
[Ralph Johnson]
	
Controlled access to the sole instance. Because the singleton class 
encapsulates the sole instance it can have strict control over how and 
when clients access it.

Reduced Name spaces. The singleton pattern is an improvement
over global variables. It avoids polluting the name space with global 
variables that store sole instances.
 
Use Singleton pattern when

there must be exactly one instance of a class and it must be a 
accessible to clients from a well known access point.

the sole instance should be extensible by subclassing and clients
should be able to use an extended instance without modification.



 

  
Structural Patterns
  

  Part 1 || 
  Part 2
 

Structural patterns prescribe the organization of classes and objects,
how classes and objects can be combined to form larger structures. 

These patterns introduce a level of indirection between a client class 
and a class it wants to use. 

The difference between class structural patterns and object structural
patterns is that class patterns describe how inheritance can be used
to provide more useful program interfaces. Object patterns, on the 
other hand, describe how objects can be composed into larger structures
using object composition or the inclusion of objects within other objects



 

  
The Adapter Pattern
  

  Part 1 || 
  Part 2
 

Definition

Convert the interface of a class into another interface clients 
expect. Adapter lets classes work together that couldn't otherwise 
because of incompatible interfaces -- The GOF Book

We use adapters whenever we want unrelated classes to work together
in a single program. The concept of an adapter is thus pretty simple; 
we write a class that has the desired interface and then make it 
communicate with the class that has a different interface. - J W Cooper.

Advantages:

Allows two or more incompatible objects to communicate and interact

Improves reusability of older / existing functionality.


Use Adapter Pattern when:

you want to use an existing class, and its interface does not match
the one you need.

you want to create a reusable class that cooperates with unrelated 
or unforseen classes, that is , classes that dont necessarily have 
compatible interfaces.

you need to use several existing subclasses, but its impracticle to
adapt their interface by subclassing every one. An Object adapter can 
adapt the interface of its parent class.



 

  
The Bridge Pattern
  

  Part 1 || 
  Part 2
 

Definition

Decouple the abstraction (read Interface) from the implementation
so that the two can vary independantly -- The GOF Book

Advantages

Decoupling Interface and Implementation using bridge pattern allows us
to configure the implementation of an abstraction at runtime.

Eliminates compile time dependencies.(Changing the implementation 
will have no effect on the Abstraction)


Use Bridge Pattern when:

you want to avoid permenantly binding an abstraction and its 
implementation. e.g. When Implementation must be selected or switched
at run-time.

Both the abstraction and the implementation must be extensible by 
subclassing and changes to either one should not impact the other.

you want to share an implementation among multiple objects and
this fact should be hidden from clients.



 

  
Composite Pattern
  

  Part 1 || 
  Part 2
 

Definition

Compose Objects into Tree Structures to represent Part Whole 
Hierarchies. Composite lets you treat composite and primitive objects 
uniformly -- The GOF Book

Advantages:

Defines class hierarchies consisting of primitive and composite 
objects.

Makes it easy to add new kinds of components.

Provides flexibility of structure and a manageable interface.

Use Composite Pattern when:

you want to represent part-whole hierarchies of objects.

you want clients to be able to ignore the difference between 
compositions of objects and individual objects.



 

  
Decorator Pattern
  

  Part 1 || 
  Part 2
 

Definition

Attach additional responsibility to an object dynamically. They
provide a flexible alternative to subclassing for extending 
functionality -- The GOF Book

The purpose of the Decorator pattern is to extend the functionality of
the original class in a way that is transparent to the client class.

Advantages

More flexibility that static inheritance. Responsibilities can be 
added or removed at runtime. Also nesting of decorators is easy.

Avoids feature laden classes high up in the hierarchy

Simplifies coding because you write a series of classes, each 
targetting a specific part of the functionality, rather than coding
all behavior into the object.
Use Decorator Pattern when:

You want to add responsibility to individual objects dynamically 
and transparently. 

You want to add responsibility to the object that you might want 
to change later.

When extension by subclassing is impractical.



 

  
Facade Pattern
  

  Part 1 || 
  Part 2
 

Definition

Provide a unified interface to a set of interfaces in a subsystem.
Facade defines a high-level interface that makes the subsystem easier 
to use-- The GOF Book


Advantages

The Facade pattern shields clients from complex subsystem components
and provides a simpler interface to complex systems without reducing 
the options provided by the system.

Facade allows you to make changes in the underlying subsystems without
requiring changes in the client code, and reduces compilation 
dependencies.

Use Facade Pattern when:

You want to provide a simple interface to a complex subsystem

There are many dependencies between clients and the implementation 
classes of an abstraction.

You want to layer your subsystems.



 

  
Flyweight Pattern
  

  Part 1 || 
  Part 2
 

Definition

Provide a unified interface to a set of interfaces in a subsystem.
Facade defines a high-level interface that makes the subsystem easier 
to use-- The GOF Book


Advantages

The Facade pattern shields clients from complex subsystem components
and provides a simpler interface to complex systems without reducing 
the options provided by the system.

Facade allows you to make changes in the underlying subsystems without
requiring changes in the client code, and reduces compilation 
dependencies.

Use Facade Pattern when:

You want to provide a simple interface to a complex subsystem

There are many dependencies between clients and the implementation 
classes of an abstraction.

You want to layer your subsystems.

Behavioural Patterns