Upload by MAlik Sajid

1. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Objectives
Lecture 13
Creational Design Pattern
SWE 316: Software Design and Architecture
 To learn the creational design
patterns and when to use them.
Ch 7Adapted from Software Design: From Programming
to Architecture by Eric J. Braude (Wiley 2003), with
permission.

2. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Creational design patterns to be covered
 Creational design patterns:
 Singleton
 Factory
 Abstract factory
 Prototype
Singleton Factory Abstract Factory Prototype Summary 2/27

3. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Singleton Design Pattern
 Intent/ Design Purpose
 when a class has exactly one instance.
 Ensure that there is exactly one instance of a class S.
Be able to obtain the instance from anywhere in the
application.
 Problem
Application needs one, and only one, instance of an object.
Additionally, lazy initialization and global access are
necessary.
 Design Pattern Summary
 Make the constructor of S private; define a private
static attribute for S of type S; define a public
accessor for it.
7.3
Singleton Factory Abstract Factory Prototype Summary 3/27

4. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Singleton applicability
 Use the singleton pattern when
 There must be exactly one instance of a class, and it must
be accessible to client from a well-known access point.
 When the sole instance should be extensible by
subclassing, and clients should be able to use an
extended instance without modifying their code.
Singleton enforces the intention that only one User
object exists, safeguarding the application from
unanticipated User instance creation.
KEY CONCEPT
Design Goal: Correctness
Singleton Factory Abstract Factory Prototype Summary 4/27

5. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Singleton consequences
 Singleton has following benefits:
 Controlled access to sole instance.
 Permits a variable number of instances.
 More flexible than class operations.
Singleton Factory Abstract Factory Prototype Summary 5/27

6. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Singleton: Class Model
MyClass
getSingletonOfMyClass(): MyClass
Client
1
singletonOfMyClass
«static»
Singleton Factory Abstract Factory Prototype Summary 6/27

7. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Singleton: Sample code
7
Define a private static member
variable of type MyClass
1
Make the constructor of MyClass private2
Define a public
static method to
access the member
3
Singleton Factory Abstract Factory Prototype Summary 7/27

8. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Comments on Singleton
 This form of Singleton is simple but it creates the
Singleton object even if the object is never needed; this
is wasteful if Singleton is large.
 The idea of Singleton can be extended to the problem
of having just two instances of a class.
When a class must have exactly one instance,
make the constructor private and the instance a
private static variable with a public accessor.
KEY CONCEPT
Singleton Design Pattern
Singleton Factory Abstract Factory Prototype Summary 8/27

9. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Factory Design Pattern
 Design Purpose
Create individual objects in situations where the
constructor alone is inadequate.
 Design Pattern Summary
Use methods to return required objects.
7.2
Singleton Factory Abstract Factory Prototype Summary 9/27

10. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Factory Class Model
Factory design pattern
MyClass
createObjectOfRequiredClass(): RequiredClass
«create object»
RequiredClassClient
Singleton Factory Abstract Factory Prototype Summary 10/27

11. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Application
of Factory
design
pattern
Factory Example (Figure 7.4)
Ford
createAutomobile()
Toyota
createAutomobile()
Automobile
createAutomobile(): Automobile
Client
«create object» «create object»
We want to write code about automobiles in general: Code that
applies to any make, exercised repeatedly (thus reliably).
KEY CONCEPT
Design Goal : Reusability and Correctness
Singleton Factory Abstract Factory Prototype Summary 11/27

12. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Application of Factory design pattern
Client
sendMessage()
Customer
getMessage()
Frequent
getMessage()
Returning
getMessage()
Curious
getMessage()
Newbie
getMessage()
MailMessage
text
MailGenerationApplication
getCustomerTypeFromUser()
«setup»
Factory: Email Generation Example
Singleton Factory Abstract Factory Prototype Summary 12/27

13. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Comments on Factory
 Applications of Factory have been increasingly
common in API’s because they improve robustness by
ensuring that objects created respect necessary
constraints.
Singleton Factory Abstract Factory Prototype Summary 13/27

14. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Abstract Factory
 Design Purpose
“Provide an interface for creating families of related or
dependent objects without specifying their concrete
classes.”*
 Design Pattern
Capture family creation in a class containing a factory
method for each class in the family.
* Gamma et al
7.4
Singleton Factory Abstract Factory Prototype Summary 14/27

15. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Abstract Factory*
Abstract Factory Interface (Figure 7.17)
Style….
Client
StyleAFactory StyleBFactory
Ensemble
setAbstractFactory()
doAFunction()
AbstractFactory
getAPart1Object()
getAPart2Object()
* relationships within pattern application not shown
Singleton Factory Abstract Factory Prototype Summary 15/27

16. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Application of Abstract Factory
Interface of Abstract Factory Applied to Word
Processor
Client
SmallStyle LargeStyle
StyleDocument
setStyle()
display()
. . . . . . .
1
Singleton Factory Abstract Factory Prototype Summary 16/27

17. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
«create»
The Abstract Factory Idea (Figure 7.19)
AbstractFactory
getAPart1Object()
getAPart2Object()
StyleAFactory
getAPart1Object()
getAPart2Object()
Part1StyleA Part2StyleA
Part1 Part2
abstractFactory 1
Ensemble
setAbstractFactory()
doAFunction()
Client
Singleton Factory Abstract Factory Prototype Summary 17/27

18. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
«create»
Abstract Factory (Figure 7.20)
Style….
AbstractFactory
getAPart1Object()
getAPart2Object()
StyleAFactory StyleBFactory
Part1StyleA Part1StyleB Part2StyleA Part2StyleB
Part1 Part2
abstractFactory 1
Ensemble
doAFunction()
Client
1..n1..n
Part…
Singleton Factory Abstract Factory Prototype Summary 18/27

19. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
We want to separate the code parts that format the
document in each style. We also want to separate the
common document generation code. This facilitates
reusing parts and checking for correctness.
KEY CONCEPT
Design Goals : Correctness and Reusability
Singleton Factory Abstract Factory Prototype Summary 19/27

20. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
To design an application in which there are several
possible styles for a collection of objects, capture styles
as classes with coordinated factory methods.
KEY CONCEPT
Abstract Factory Design Pattern
Singleton Factory Abstract Factory Prototype Summary 20/27

21. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Prototype Design Pattern
 Design Purpose
 Create a set of almost identical objects whose type is
determined at runtime.
 Assume that a prototype instance is known; clone it
whenever a new instance is needed.
-- when designing for multiple
instances which are the same in
key respects, create them by
cloning a prototype.
KEY CONCEPT
Prototype Pattern
Singleton Factory Abstract Factory Prototype Summary 21/27

22. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Prototype Design Example: A Selection
Graphics courtesy COREL
Click on choice of storage:
Click on choice of chair:
Click on choice of desk:Furnit
ure
color
Furnitu
re
hardwa
re typecoloni
al
Adapted from Software Design:
From Programming to
Architecture by Eric J. Braude
(Wiley 2003), with permission.
Singleton Factory Abstract Factory Prototype Summary 22/27

23. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Prototype consequences
 It hides the concrete product classes from the client.
 It let client work with application-specific classes
without modification.
 It adds and removes products at run-time.
 It configures an application with classes dynamically.
Singleton Factory Abstract Factory Prototype Summary 23/27

24. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
The Prototype Idea
Ensemble
createEnsemble()
Client
MyPart
clone(): MyPart
MyPartStyleA
clone()
MyPartStyleB
clone()
myPartPrototype 1
// To create a MyPart instance:
MyPart p = myPartPrototype.clone();
Singleton Factory Abstract Factory Prototype Summary 24/27

25. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Prototype Class Model
Ensemble
createEnsemble()
Client
Part1StyleA
clone()
Part1StyleB
clone()
Part2StyleA
clone()
Part2StyleB
clone()
Part1
clone()
Part2
clone()
part1Prototype part2Prototype
1 1
.....
// To create a Part1 object:
Part1 p1 = part1Prototype.clone();
….
Part1StyleB returnObject = new Part1StyleB();
….
Part1StyleC
clone()
Singleton Factory Abstract Factory Prototype Summary 25/27

26. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
We want to isolate the parts pertaining to each type of
customer. We also want to isolate the common
customer code. This makes it easier to check the
design and implementation for correctness, and to
reuse the parts.
KEY CONCEPT
Design Goals : Correctness and Reusability
Singleton Factory Abstract Factory Prototype Summary 26/27

27. SWE 316: Software Design and Architecture – Dr. Khalid Aljasser
Summary of Creational Patterns
 Use Creational Design Patterns when creating complex
objects
 Singleton
 for exactly one, safely
 when a class has exactly one instance
 Factory when creating individuals
 Abstract Factory when creating families
 Prototype to “mix & match”
Singleton Factory Abstract Factory Prototype Summary 27/27