Chapter 3

Design Patterns

By Destaye A.
 Contents
 Introduction: Origine of Design Patterns
 What are design patterns?
 Examples of patterns
 Benefits Patterns
 Types of design patterns
 Creational Design Patterns
 Factory Method
 Singleton Pattern
 Structural Design Patterns
 Adapter Pattern
 Facade Pattern
 Behavioral Design Pattern
 Iterator Pattern
 Origins of Design Patterns
“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“
Christopher Alexander, A Pattern Language, 1977
 What are Design Patterns?
 Software design pattern is
 a generalized reusable solution
 to a commonly occurring problem in software design
 in defined context ( the general situation in which pattern applies)
 A design pattern is not a finished design that can be transformed
directly into code.
 It is a description or template for how to solve a problem that can be
used in many different situations
 Many of them have been systematically documented for all software
developers to use
 A good pattern should be as general as possible contain a solution
that has been proven to effectively solve the problem in the indicated
context.
 Elements of Design Patterns
 Design patterns must be described in an easy-to-understand form so
that people can determine when and how to use it.
 Minimum parameters to describe patterns are
 Name - Important because it becomes part of a design vocabulary
 Problem - describes intent, context, and when the pattern is applicable
 Solution - Design elements and their relationships.
 Consequences - Tradeoffs of applying the pattern
 Each pattern has costs as well as benefits
 Issues include flexibility, extensibility, etc.
 Each pattern in Gang of Four (GoF) is documented with following
specifications:
 Intent, also known as, motivation, applicability, structure, participants,
collaborations, consequences, implementation, sample code, known uses,
related patterns
 Examples of patterns
 Design patterns you have already seen
 Encapsulation (Data Hiding)
 Sub-classing (Inheritance)
 Iteration
 Exceptions
 Encapsulation Pattern
 Problem: Exposed fields are directly manipulated from outside,
leading to undesirable dependences that prevent changing the
implementation.
 Solution: Hide some components, permitting only stylized
access to the object.
 Exemples of patterns…
 Sub-classing pattern
 Problem: Similar abstractions have similar members (fields and methods).
Repeating these is tedious, error-prone, and a maintenance headache.
 Solution: Inherit default members from a super-class; select the correct
implementation.
 Iteration pattern
 Problem: Clients that wish to access all members of a collection must perform
a specialized traversal for each data structure.
 Solution: Implementations perform traversals. The results are communicated
to clients via a standard interface.
 Exceptions Pattern
 Problem: Code is cluttered with error-handling code.
 Solution: Errors occurring in one part of the code should often be handled
elsewhere. Use language structures for throwing and catching exceptions.
 Why Patterns?
 Speed up the development process by providing tested, proven
development paradigms.
 Shared language of design
 Increases communication bandwidth because it has consistent
documentation
 Decreases misunderstandings
 Learn from experience
 Becoming a good designer is hard
 Understanding good designs is a first step
 Tested solutions to common problems
 Used to achieve the following quality attributes;
 Modifiability, Exchangeability, Reusability, Extensibility, Maintainability,
Reliability, Testability, …
 Patterns help you to manage software complexity.
 Types of Design Patterns
 Design pattern are applied at different levels such as frameworks, and
subsystems
 GRASP Patterns
 General Responsibility Assignment Software Pattern
 E.g. Information Expert, Creator, Low Coupling, High Cohesion
 Architectural patterns
 An architectural pattern express a fondamental structural organisation
schéma for software Systems
 Design patterns
 Creational Patterns- initializing and configuring classes and objects
 Structural Patterns - integration and composition of classes and objects
 Behavioral Patterns -dynamic interactions among societies of classes and
objects
 Idioms
 An Idiom is a low-level patterns specific to a programming language.
 Design Patterns space
Purpose
Defer object creation to
another class
Creational Structural Behavioral
Scope Abstract Factory Adapter (object) Chain of
Builder Bridge Responsibility
Prototype Composite Command
Singleton Decorator Iterator
Facade Mediator
Flyweight Memento
Proxy Observer
State
Strategy
Defer object creation to Visitor
another object Describe ways to Describe algorithms and
assemble objects flow control

AP 04/02
 Creational Patterns
 Abstract the instantiation process
 Make a system independent of how its objects are created, composed,
and represented
 Creational pattern support the creation process by helping to
provide the following capabilities
 Generic instantiation – allows objects to be created in a system
without having to identify a specific class type in code.
 Simplicity – some patterns make object creation easier so callers will
not have to write large, complex code to instantiate an object.
 Creation constraint – some patterns create constraints on the type or
number of objects that can be created within a system.
 Factory Method pattern
 The creation of an object often requires complex processes which is
not appropriate to include within a composing object.
 Intent: Define an interface for creating an object, but let subclasses
decide which class to instantiate. Factory Method lets a class defer
instantiation to subclasses.
 Factory Method pattern…
 The participants classes in this pattern are:
 Product - defines the interface for objects the factory method creates.
 ConcreteProduct - implements the Product interface.
 Creator(also refered as Factory because it creates the Product objects)
declares the method FactoryMethod, which returns a Product object.
May call the generating method for creating Product objects
 ConcreteCreator - overrides the generating method for creating
ConcreteProduct objects
• Example
• If we have a super class and n sub-classes, and based on data provided,
we have to return the object of one of the sub-classes, we use a factory
pattern.
 Factory Method pattern...
 Use the Factory Method pattern when
 a class can´t anticipate the class of objects it must create.
 a class wants its subclasses to specify the objects it creates.
 classes delegate responsibility to one of several helper subclasses,
and you want to localize the knowledge of which helper subclass is
the delegate.
 Consequences:
 Provides hooks for subclasses
 Connects parallel class hierarchies
 Limitations
 The factory has to be used for a family of objects. If the classes doesn't
extend common base class or interface they can not be used in a factory
design template.
 Advantages of Factory Method Design Pattern

 Separates object creation from client code, enhancing flexibility

and maintainability since changes to creation don’t affect clients.
 New product types can be easily added without altering client
code by simply creating new Concrete Creator subclasses.
 Simplifies unit testing by allowing mock product creation,
enabling tests of various implementations without actual object
dependencies.
 The factory method can be reused across different application
parts
 Singleton pattern
 a class that can have only one object (an instance of the class) at a
time .
 Intent: Ensure a class only has one instance, and provide a global
point of access to it.
 Singleton pattern Example
 According to the definition the singleton pattern should be
used when there must be exactly one instance of a class, and
when it must be accessible to clients from a global access point.
 Here are some real situations where the singleton is used:
 Examples of use of singleton pattern
 The Singleton pattern is used in the design of logger classes.
 This classes are usually implemented as a singletons, and provides a
global logging access point in all the application components without
being necessary to create an object each time a logging operations is
performed.
 Singleton Pattern is also used when there is a single resource, where
there should only be a single object in charge of accessing the single
resource.
 Singleton pattern ...
 Use the Singleton pattern when
 there must be exactly one instance of a class, and it must be accessible
to clients from a well-known access point.
 when the sole instance should be extensible by sub classing, and clients
should be able to use an extended instance without modifying their
code.
 Consequences
 Controlled access to sole instance
 Reduced name space
 Permits refinement of operations and representations
 Permits a variable number of instances
 More flexible than class operations
purpose of Singleton class
 to restrict the limit of the number of object creations to only
one. This often ensures that there is access control to
resources,
 Memory space wastage does not occur with the use of the
singleton class because it restricts instance creation
 Structural Patterns
 Structural Design Patterns solves problems related to how
classes and objects are composed/assembled to form larger
structures which are efficient and flexible in nature.
 It use inheritance to compose interfaces or implementations.
structural object patterns describe ways to compose objects to
realize new functionality.
 The added flexibility of object composition comes from the
ability to change the composition at run-time.
Structural Patterns
 Adapter/wrapper Pattern
 Intent The Adapter design pattern is a structural pattern that allows the interface of an
existing class to be used as another interface. It acts as a bridge between two
incompatible interfaces, making them work together. This pattern involves a single class,
known as the adapter, which is responsible for joining functionalities of independent or
incompatible interfaces
The classes/objects
participating in adapter
pattern:
 Target - defines the
domain-specific
interface that Client
uses.

 Adapter - adapts the interface Adaptee to the Target interface.

 Adaptee - defines an existing interface that needs adapting.
 Client - collaborates with objects conforming to the Target interface
 The adapter pattern convert the interface of a class into
another interface clients expect.
 Adapter lets classes work together that couldn’t otherwise
because of incompatible interfaces
 Adapter Pattern …
 Adapter classes could be object adapter or class adapter
 Objects Adapters - Based on Delegation

 Objects Adapter uses composition, the Adaptee delegates the calls to

Adaptee (opposed to class adapters which extends the Adaptee).

 Class Adapter – Based on (Multiple) Inheritance

 Class adapters can be implemented in languages supporting multiple

inheritance .
 Adapter Pattern …
 Use Adapter when you
 want to use an existing class, and its interface doesn’t match the one you
need.
 want to create a reusable class that cooperates with unrelated or
unforeseen classes
 need to use several existing subclasses, but it's impractical to adapt their
interface by sub-classing every one.
 Consequences:
 A class adapter
 lets Adapter override some of Adaptee's behavior, since Adapter is a
subclass of Adaptee.
 introduces only one object, and no additional pointer indirection is
needed to get to the adaptee.
 An object adapter
 lets a single Adapter work with many Adaptees
 makes it harder to override Adaptee behavior.
 Facade Pattern
 Intent: Provide a unified interface to a set of interfaces in a
subsystem. Facade defines a higher-level interface that makes the
subsystem easier to use.
Make a complex system simpler by providing a unified or general
interface, which is a higher layer to these subsystems.
 Façade Pattern…
 Use Façade 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.
 Consequences:
 It shields clients from subsystem components
 It promotes weak coupling between the subsystem and its
clients.
 Behavioral Design Patterns
 Behavioral design patterns are design patterns that identify
common communication patterns between objects and realize
these patterns.
 By doing so, these patterns increase flexibility in carrying out this
communication.
 Behavioral patterns are those which are concerned with
interactions between the objects.
 The interactions between the objects should be such that they are
talking to each other and still are loosely coupled.
List of Behavioral Patterns
 Interpreter Pattern
 Interpreter pattern is used to defines a grammatical representation
for a language and provides an interpreter to deal with this
grammar

Template Pattern
 The template method design pattern defines an algorithm as a
collection of skeleton operations, with the child classes handling the
implementation of the specifics.
 The parent class maintains the overall structure and flow of the
algorithm
State Pattern

 When an object modifies its behavior according to its

internal state, the state design pattern is applied.
 If we have to change the behavior of an object based on its
state, we can have a state variable in the Object and use the
if-else condition block to perform different actions based on
the state.