Design Pattern in Software Engineering

1
Gul Sher Ali
BS(Hons) CS - UOG
MS(CS & Tech.)-China
Software Engineering II(CS-552)
______________________________________________________
GIMS- PMAS Arid Agriculture University, Gujrat Campus

Design Pattern
 In software engineering, a design pattern is a general repeatable solution
to a commonly occurring problem in software design.[1]
Figure : 1 Design Patterns[4]

Uses of Design Patterns
Design patterns can speed up the development
process by providing tested, proven development
paradigms.
 Effective software design requires considering issues
that may not become visible until later in the
implementation.
 Reusing design patterns helps to prevent subtle
issues that can cause major problems and improves
code readability for coders and architects familiar
with the patterns.

Types of Design Pattern In
Software Engineering
Creational Patterns
Structural Patterns
Behavioral Patterns

Creational Design Patterns
In software engineering, creational design patterns
are design patterns that deal with object creation
mechanisms, trying to create objects in a manner
suitable to the situation.

Types of Creational design Patterns
Abstract Factory
Builder
Factory Method
Prototype
Singleton

Abstract Factory
 Provide an interface for creating families of related or dependent objects
without specifying their concrete classes.[4]
Figure : 2 Abstract Factory [4]

Builder
 Separate the construction of a complex object from its representation so
that the same construction process can create different
representations.[5]
Figure : 3 Builder [3]

Factory method
 Define an interface for creating an object, but let subclasses decide which
class to instantiate. Factory Method lets a class defer instantiation to
subclasses.[5]
Figure : 4 Factory Method [4]

Prototype
Start with an initialized and instantiated class and
copy or clones it to make new instances rather than
creating to a new instances.[5]

Singleton
A class of which only a single instance can exist and
provide a global point of access to it.[5]

Structural Pattern
These concern class and object composition. They
use inheritance to compose interfaces and define
ways to compose objects to obtain new
functionality.

Types of Structural Pattern
Adapter
Bridge
Composite
Decorator
Façade
Flyweight
Proxy

Adapter
 Adapter allows classes with incompatible interfaces to work together by
wrapping its own interface around that of an already existing class.[4]
Figure 5: Adapter Pattern[4]

Bridge
 Bridge pattern intended to keep the interface to your client program
constant while allowing you to change the actual kind of class you display
or used. You can then change the interface and underline class
separately.[5]
 A household switch controlling lights, ceiling fans, etc. is an example of
the Bridge.[3]

Composite
 The Composite composes objects into tree structures, and
lets clients treat individual objects and compositions
uniformly.[3]

Decorator
 A Class that surrounds a given class, adds new capabilities to it, and
passes all the unchanged methods to the underlying class.[5]
Figure 7: Decorator Pattern[4]

Facade
Facade provides a simplified interface to a large body
of code.[6]
Figure 8: Facade Pattern[4]

Flyweight
Reduces the cost of creating and manipulating a
large number of similar objects.
It provides a way to limit the proliferation of small
similar class instances by moving some of class data
outside the class and passing it in during various
execution method.

Proxy
Provides a placeholder for another object to control
access, reduce cost, and reduce complexity.

Behavioral Patterns
Most of these design patterns are specifically
concerned with communication between objects.

Types of Behavioral Pattern
Chain of Responsibility
Command
Interpreter
Iteretor
Mediator
Observer
State
Strategy
Template Method
Visitor

Chain of Responsibility
The main purpose of this pattern is to reduce
coupling between objects and object only need to
know how to forward the request to other objects.

Command
It encapsulates a
request as an object
there by letting you
parameterized other
objects with different
request, queue or log
request and support
undoable operations.
Figure 9: Command Pattern[4

Interpreter
Interpreter provides a definition of how to include
language elements in a program.

Iterator
Accesses the elements of an object sequentially
without exposing its underlying representation.

Mediator
Allows loose coupling between classes by being the
only class that has detailed knowledge of their
methods.

Observer
Observer is a publish/subscribe pattern which allows
a number of observer objects to see an event.
Figure 10: Observer Pattern[4]

State
State allows an object to alter its behavior when its
internal state changes.

Strategy
Strategy allows one of a family of algorithms to be
selected on-the-fly at runtime.

Template Method
 Template method defines the skeleton of an algorithm as an abstract
class, allowing its subclasses to provide concrete behavior.
Figure 11: Template Pattern[4]

Visitor separates an algorithm from an object
structure by moving the hierarchy of methods
into one object.

Memento Pattern
If you want to save the internal state of an object so
you can restore it later ideally it should be possible
to save and restore this state without making the
object itself take care of this task.
Figure : 12 Memento Pattern[3]

Design Pattern in Software Engineering

More Related Content

What's hot (20)

Similar to Design Pattern in Software Engineering (20)

Recently uploaded (20)

Design Pattern in Software Engineering