Introduction
"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
Benefits
Design patterns have two major benefits.
- 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.
- 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
![DesignPatterns.gif]()
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