Design Patterns Part - I


"Pattern is a recurring solution to a standard problem"
as per "Christopher Alexander"

"Each Pattern describes a problem which occurs over and over 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".

What is Design Patterns?

Design patterns are recurring solutions to software design problems you find again and again in real-world application development. Design patterns are about design and interaction of objects, as well as providing a communication platform concerning elegant, reusable solutions to commonly encountered programming challenges.

Design patterns make it easier to reuse successful designs and architectures.

In General pattern has four essential elements:

  • Pattern Name
    Naming a pattern immediately increases our design vocabulary. It let's design at a higher level of abstraction.

  • Problem
    It explains the problem and its context. It might describe specific design problems such as how to represent algorithms as objects.

  • Solution
    The solution describes the elements that make up the design, their relationships, responsibilities, and collaborations.

  • Consequences
    The consequences are the results and trade-offs of applying the pattern

Why Design Patterns?

Design Pattern systematically names, explains, and evaluates an important and recurring design in object-oriented systems. Design patterns capture design experience in a form that people can use effectively. Design patterns make it easier to reuse successful designs and architectures. Expressing proven techniques as design patterns makes them more accessible to developers of new systems

Design patterns help you choose design alternatives that make a system reusable and avoid alternatives that compromise reusability. Design patterns can even improve the documentation and maintenance of existing systems by furnishing an explicit specification of class and object interactions and their underlying intent.

What Experienced Programmers do?

Experienced programmers not to solve every problem from first principles. Reuse solutions that have worked for them in past, when they find a good solution, they use it again and again. Consequently, well find recurring patterns of classes and communicating objects in many object-oriented systems


Design patterns have two major benefits.

  1. First, they provide you with a way to solve issues related to software development using a proven solution. The solution facilitates the development of highly cohesive modules with minimal coupling. They isolate the variability that may exist in the system requirements, making the overall system easier to understand and maintain.

  2. Second, design patterns make communication between designers more efficient. Software professionals can immediately picture the high-level design in their heads when they refer the name of the pattern used to solve a particular issue when discussing system design.

Using Design Patterns in UML

Ok so you might ask how does a pattern relate to the UML?

The patterns that we encounter need to be captured and documented in a sufficiently descriptive manner so that they can be referred for future use. UML provides the perfect tools to do just this.

The class diagram in UML can be used to capture the patterns identified in a system. In addition, UML has a sufficiently extensive and expressive vocabulary to capture the details of patterns. Building on this background we will see how to leverage the usefulness of well-known patterns to make application designing a lot easier.

To sum up, a pattern should have the following characteristics

  • Useful Solution
  • Reusable
  • Contextual

Pattern Forms
To give you a head start, the design patterns can provided in two forms: 

  • Structural  
    Structural code uses type names as defined in the pattern definition and UML diagrams. 

  • Real-world 
    Real-world code provides real-world programming situations where you may use the patterns

Types of Patterns
The Gang of Four (GOF) patterns is generally considered the foundation for all other patterns.
They are categorised in three groups:

  • Creational
  • Structural
  • Behavioural

Catalogue of Design Patterns


Creational Patterns

Creational class patterns defer some part of object creation to subclasses, while Creational object patterns defer it to another object.

  • Abstract Factory  
    Creates an instance of several families of classes

  • Builder   
    Separates object construction from its representation

  • Factory Method  
    Creates an instance of several derived classes

  • Prototype  
    A fully initialised instance to be copied or cloned

  • Singleton   
    A class of which only a single instance can exist

Structural Patterns

The Structural class patterns use inheritance to compose classes, while the Structural object patterns describe ways to assemble objects.

  • Adapter   
    Match interfaces of different classes

  • Bridge    
    Separates an object's interface from its implementation

  • Composite   
    A tree structure of simple and composite objects

  • Decorator   
    Add responsibilities to objects dynamically

  • Facade   
    A single class that represents an entire subsystem

  • Flyweight  
    A fine-grained instance used for efficient sharing

  • Proxy    
    An object representing another object

Behavioural Patterns

The Behavioural class patterns use inheritance to describe algorithms and flow of control, whereas the Behavioural object patterns describe how a group of objects co-operate to perform a task that no single object can carry out alone.

  • Chain of Responsibility.   
    A way of passing a request between a chain of objects

  • Command   
    Encapsulate a command request as an object

  • Interpreter   
    A way to include language elements in a program

  • Iterator    
    Sequentially access the elements of a collection

  • Mediator   
    Defines simplified communication between classes

  • Memento   
    Capture and restore an object's internal state

  • Observer    
    A way of notifying change to a number of classes

  • State    
    Alter an object's behaviour when its state changes