The document provides an extensive overview of design patterns in software development, particularly focusing on the concepts established by the 'Gang of Four'. It covers various design patterns such as creational, structural, and behavioral patterns, detailing their applications, implementations, and benefits. Additionally, it includes specific examples and code illustrations for critical patterns like Singleton, Abstract Factory, and Builder.

1. Design Patterns (DP)
By P. S. Suryateja
Asst. Professor
CSE Dept
Vishnu Institute of Technology
Erich
Gamma
Richard
Helm
Ralph
Johnson
John
Vlissides
Gang of Four (GOF)

2. Objectives
• Know what are design patterns?
• Know about GOF patterns.
• How to select and use a pattern?
• How to apply a pattern?

3. Outline
• Introduction to design patterns
– What is a design pattern?
– Need of design patterns
– Use of design patterns
– Design patterns in Smalltalk MVC
– Describing design patterns
– Catalog of design patterns
– Organizing the catalog
– How to select a design pattern?
– How to use a design pattern?

4. Outline (cont…)
• Creational patterns
– Introduction
– Singleton
– Abstract Factory
– Factory Method
– Builder
– Prototype

5. Outline (cont…)
• Structural Patterns

6. Introduction to Design Patterns

7. What is a design pattern (DP)?
“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
Design patterns are repeatable / reusable solutions to
commonly occurring problems in a certain context in
software design.

8. What is a design pattern (DP)? (cont…)
• Pattern name
• Problem
• Solution
• Consequences
Four essential elements of a pattern:

9. Need for design patterns
• Designing reusable object-oriented software (API’s) is
hard.
• Experienced designers Vs novice designers.
• Patterns make object-oriented software flexible, elegant
and reusable.
• Solved a problem previously but don’t remember when
or how?

10. Use of design patterns
• Make it easier to reuse successful designs and architectures.
• Make it easy for the new developers to design software.
• Allows to choose different design alternatives to make the
software reusable.
• Helps in documenting and maintaining the software.
To get a design “right”, faster.

11. Why should we use DP’s?
These are already tested and
proven solutions used by many
experienced designers.

12. MVC Architecture

13. Design Patterns in Smalltalk MVC

14. Describing design patterns
1. Pattern name and classification
2. Intent
3. Also known as
4. Motivation
5. Applicability
6. Structure
7. Participants
8. Collaborations

15. Describing design patterns (cont…)
9. Consequences
10. Implementation
11. Sample code
12. Known uses
13. Related patterns

16. Catalog of design patterns
1. Abstract Factory
2. Adapter
3. Bridge
4. Builder
5. Chain of Responsibility
6. Command
7. Composite
8. Decorator
9. Façade
10. Factory Method

17. Catalog of design patterns (cont…)
11. Flyweight
12. Interpreter
13. Iterator
14. Mediator
15. Memento
16. Observer
17. Prototype
18. Proxy
19. Singleton
20. State

18. Catalog of design patterns (cont…)
21. Strategy
22. Template Method
23. Visitor

19. Abstract Factory

20. Adapter

21. Bridge

22. Builder

23. Chain of Responsibility

24. Command

25. Composite

26. Decorator

27. Façade

28. Factory Method

29. Flyweight

30. Interpreter

31. Iterator

32. Mediator

33. Memento

34. Observer

35. Prototype

36. Proxy

37. Singleton

38. State

39. Strategy

40. Template Method

41. Visitor

42. Organizing the catalog

43. How to select a design pattern
• Consider how design patterns solve design problems
• Scan intent sections
• Study how patterns interrelate
• Study patterns of like purpose
• Examine a cause of redesign
• Consider what should be variable in your design

44. Relationships
between
patterns

45. How to use a design pattern
1. Read the pattern once through for a overview.
2. Study the structure, participants and collaborations sections.
3. Look at the sample code section to see a concrete example of
the pattern in action.
4. Choose names for pattern participants that are meaningful in
the application context.
5. Define the classes.
6. Define application-specific names for the operations in the
pattern.
7. Implement the operations to carry out the responsibilities and
collaborations in the pattern.

46. Creational Patterns

47. Introduction
• Deals with how objects are created.
• Increase the system’s flexibility in terms of what, who, how and when the object is
created.
• Further classified into two types:
1. Class-creational patterns
2. Object-creational patterns
• Five creational patterns:
1. Abstract Factory
2. Builder
3. Factory Method
4. Prototype
5. Singleton

48. Singleton Pattern
• To create exactly one object of a class and to
provide a global point of access to it.
Structure

49. Singleton Pattern (cont…)
Non-Software Example

50. Singleton Pattern (cont…)
Motivation:
1) Need to create exactly one user interface
object.
2) Need to create only one print spooler.

51. Singleton Pattern (cont…)
Applicability:
Singleton Pattern can be used when:
1)There must be exactly one instance of a class
and to provide a global point of access to it.
2)When the sole instance should be extensible by
sub classing, and clients should be able to use the
extended instance without modifying its code.

52. Singleton Pattern (cont…)
Participants:
Consists of a “Singleton” class with the
following members:
1)A static data member
2)A private constructor
3)A static public method that returns a reference
to the static data member.

53. Singleton Pattern (cont…)
Collaborations:
Clients access the singleton instance solely
through the singleton’s class operation.

54. Singleton Pattern (cont…)
Consequences:
• Controlled access to sole instance.
• Reduced name space.
• Permits refinement of operations and
representation.
• Permits a variable number of instances.

55. Singleton Pattern (cont…)
Implementation:
class Singleton
{
private static Singleton instance;
private Singleton()
{
...
}
public static synchronized Singleton getInstance()
{
if (instance == null)
instance = new Singleton();
return instance;
}
...
public void doOperation()
{
...
}
}

56. Singleton Pattern (cont…)
Sample code:
Design a small ATM printing application which can
generate multiple types of statements of the transaction
including Mini Statement, Detailed statement etc.
However the customer should be aware of the creation of
these statements. Ensure that the memory consumption is
minimized.

57. Singleton Pattern (cont…)
Real World Example

58. Singleton Pattern (cont…)
Code for StatementFactory class is as shown below:
public class StatementFactory extends Factory
{
private static StatementFactory uniqueInstance;
private StatementFactory() {}
public static StatementFactory getUniqueInstance()
{
if (uniqueInstance == null)
{
uniqueInstance = new StatementFactory();
System.out.println("Creating a new StatementFactory instance");
}
return uniqueInstance;
}

59. Singleton Pattern (cont…)
public StatementType createStatements(String selection)
{
if (selection.equalsIgnoreCase("detailedStmt"))
{
return new DetailedStatement();
}
else if (selection.equalsIgnoreCase("miniStmt"))
{
return new MiniStatement();
}
throw new IllegalArgumentException("Selection doesnot exist");
}
}

60. Singleton Pattern (cont…)
Related Patterns:
Other patterns like Abstract Factory, Builder
and Prototype can be implemented using the
Singleton pattern.

61. Abstract Factory Pattern
• Provides an interface to create a family of related objects,
without explicitly specifying their concrete class.

62. Abstract Factory Pattern (cont…)
Non-Software Example

63. Abstract Factory Pattern (cont…)
Also known as:
Kit

64. Abstract Factory Pattern (cont…)
Motivation:
Creating interface components for different look and feels.

65. Abstract Factory Pattern (cont…)
Applicability:
We should use Abstract Factory design pattern when:
• The system needs to be independent of the products it works with are
created.
• The system should be configured to work with multiple families of
products.
• A family of products is designed to be used together and this constraint is
needed to be enforced.
• A library of products is to be provided and only their interfaces are to be
revealed but not their implementations.

66. Abstract Factory Pattern (cont…)
Participants:
The classes that participate in the Abstract Factory are:
• AbstractFactory: Declares an interface of operations that create abstract
products.
• ConcreteFactory: Implements operations to create concrete products.
• AbstractProduct: Declares an interface for a type of product objects.
• Product: Defines a product to be created by the corresponding
ConcreteFactory. It implements the AbstractProduct interface.
• Client: Uses the interfaces declared by the AbstractFactory and
AbstractProduct classes.

67. Abstract Factory Pattern (cont…)
Collaborations:
• The ConcreteFactory class creates products
objects having a particular implementation.
To create different product, the client should
use a different concrete factory.
• AbstractFactory defers creation of product
objects to its ConcreteFactory subclass.

68. Abstract Factory Pattern (cont…)
Consequences:
Following are the benefits and liabilities of Abstract Factory
pattern:
• It isolates concrete classes.
• It makes exchanging product families easy.
• It creates consistency among products.
• Supporting new kinds of products is difficult.

69. Abstract Factory Pattern (cont…)
Implementation:
abstract class AbstractProductA
{
public abstract void operationA1();
public abstract void operationA2();
}

70. Abstract Factory Pattern (cont…)
class ProductA1 extends AbstractProductA
{
ProductA1(String arg)
{
System.out.println("Hello "+arg);
}
// Implement the code here
public void operationA1() { };
public void operationA2() { };
}
class ProductA2 extends AbstractProductA
{
ProductA2(String arg)
{
System.out.println("Hello "+arg);
}
// Implement the code here
public void operationA1() { };
public void operationA2() { };
}

71. Abstract Factory Pattern (cont…)
abstract class AbstractProductB
{
public abstract void operationB1();
public abstract void operationB2();
}

72. Abstract Factory Pattern (cont…)
class ProductB1 extends AbstractProductB
{
ProductB1(String arg)
{
System.out.println("Hello "+arg);
}
// Implement the code here
}
class ProductB2 extends AbstractProductB
{
ProductB2(String arg)
{
System.out.println("Hello "+arg);
}
// Implement the code here
}

73. Abstract Factory Pattern (cont…)
abstract class AbstractFactory
{
abstract AbstractProductA createProductA();
abstract AbstractProductB createProductB();
}

74. Abstract Factory Pattern (cont…)
class ConcreteFactory1 extends AbstractFactory
{
AbstractProductA createProductA()
{
return new ProductA1("ProductA1");
}
AbstractProductB createProductB()
{
return new ProductB1("ProductB1");
}
}
class ConcreteFactory2 extends AbstractFactory
{
AbstractProductA createProductA()
{
return new ProductA2("ProductA2");
}
AbstractProductB createProductB()
{
return new ProductB2("ProductB2");
}
}

75. Abstract Factory Pattern (cont…)
class FactoryMaker
{
private static AbstractFactory pf=null;
static AbstractFactory getFactory(String choice)
{
if(choice.equals("a"))
{
pf=new ConcreteFactory1();
}
else if(choice.equals("b"))
{
pf=new ConcreteFactory2();
}
return pf;
}
}

76. Abstract Factory Pattern (cont…)
public class Client
{
public static void main(String args[ ])
{
AbstractFactory pf=FactoryMaker.getFactory("a");
AbstractProductA product=pf.createProductA();
//more function calls on product
}
}

77. Abstract Factory Pattern (cont…)
Real World Example

78. Abstract Factory Pattern (cont…)
Sample Code:
public interface Window
{
public void setTitle(String text);
public void repaint();
}

79. Abstract Factory Pattern (cont…)
//ConcreteProductA1
public class MSWindow implements Window
{
public void setTitle()
{
//MS Windows specific behaviour
}
public void repaint()
{
//MS Windows specific behaviour
}
}

80. Abstract Factory Pattern (cont…)
//ConcreteProductA2
public class MacOSXWindow implements Window
{
public void setTitle()
{
//Mac OSX specific behaviour
}
public void repaint()
{
//Mac OSX specific behaviour
}
}

81. Abstract Factory Pattern (cont…)
public interface AbstractWidgetFactory
{
public Window createWindow();
}

82. Abstract Factory Pattern (cont…)
//ConcreteFactory1
public class MsWindowsWidgetFactory
{
//create an MSWindow
public Window createWindow()
{
MSWindow window = new MSWindow();
return window;
}
}
//ConcreteFactory2
public class MacOSXWidgetFactory
{
//create a MacOSXWindow
public Window createWindow()
{
MacOSXWindow window = new MacOSXWindow();
return window;
}
}

83. Abstract Factory Pattern (cont…)
public class GUIBuilder
{
public void buildWindow(AbstractWidgetFactory widgetFactory)
{
Window window = widgetFactory.createWindow();
window.setTitle("New Window");
}
}

84. Abstract Factory Pattern (cont…)
public class Main
{
public static void main(String[] args)
{
GUIBuilder builder = new GUIBuilder();
AbstractWidgetFactory widgetFactory = null;
//check what platform we're on
if(Platform.currentPlatform()=="MACOSX")
{
widgetFactory = new MacOSXWidgetFactory();
}
else
{
widgetFactory = new MsWindowsWidgetFactory();
}
builder.buildWindow(widgetFactory);
}
}

85. Abstract Factory Pattern (cont…)
Related Patterns:
AbstractFactory classes are often implemented with factory
methods but they can also be implemented using Prototype. A
concrete factory is often a Singleton.

86. Factory Method Pattern
• Defines an interface for creating an object, but lets
subclasses decide which class to instantiate. Factory
Method lets a class defer instantiation to subclasses.

87. Factory Method Pattern (cont…)
Non-Software Example

88. Factory Method Pattern (cont…)
Also known as:
Virtual constructor

89. Factory Method Pattern (cont…)
Motivation:
Document application

90. Factory Method Pattern (cont…)
Applicability:
• A class can’t anticipate the class of objects it must
create.
• A class wants its sub classes to specify the objects
it creates.
• Classes delegate responsibility to one of several
helper subclasses.

91. Factory Method Pattern (cont…)
Participants:
• Product: Defines the interface of objects the factory method
creates.
• ConcreteProduct: Implements the Product interface.
• Creator: Declares the factory method, which returns an object
of the type Product.
• ConcreteCreator: Overrides the factory method to return an
instance of a ConcreteProduct.

92. Factory Method Pattern (cont…)
Collaborations:
Creator relies on its subclasses to provide an
implementation for the factory method so that it
returns an instance of the appropriate
ConcreteProduct class.

93. Factory Method Pattern (cont…)
Consequences:
•The main reason for which the factory pattern is used is that it introduces a
separation between the application and a family of classes.
•It provides customization hooks.
•The factory has to be used for a family of objects.

94. Factory Method Pattern (cont…)
Implementation:
public interface Product { }
public class ConcreteProduct implements Product { }
public abstract class Creator
{
public void anOperation()
{
Product product = factoryMethod();
}
protected abstract Product factoryMethod();
}
public class ConcreteCreator extends Creator
{
protected Product factoryMethod()
{
return new ConcreteProduct();
}
}

95. Factory Method Pattern (cont…)
Real World Example

96. Factory Method Pattern (cont…)
Related patterns:
• Abstract Factory is often implemented with factory methods.
• Factory methods are usually called within Template
Methods. In the Document example above, NewDocument()
is a template method.
• Prototypes don’t require subclassing Creator. Instead, they
often require an Initialize operation on the product class.
Factory Method doesn’t require such operation.

97. Builder Pattern
• Separate the construction of a complex object from
its representation so that the same construction
process can create different representations.

98. Builder Pattern (cont…)
Non-Software Example

99. Builder Pattern (cont…)
Motivation:
Text Converter

100. Builder Pattern (cont…)
Use the Builder pattern when:
• The algorithm for creating a complex object
should be independent of the parts that make
up the object and how they are assembled.
• The construction process must allow different
representations for the object that is
constructed.
Applicability:

101. Builder Pattern (cont…)
• Builder: Provides an abstract interface for creating parts of
a Product object.
• ConcreteBuilder: Constructs and assembles the parts of the
Product by implementing the Builder interface.
• Director: Constructs an object using the Builder interface.
• Product: Represents the complex object under construction.
Participants:

102. Builder Pattern (cont…)
The benefits and pitfalls of Builder pattern are:
• It let’s you vary the product’s internal
representation.
• It isolates code for construction and
representation.
• It gives you finer control over the
construction process.
Consequences:

103. Builder Pattern (cont…)
//Abstract Builder
class abstract class TextConverter
{
abstract void convertCharacter(char c);
abstract void convertParagraph();
}
// Product
class ASCIIText
{
public void append(char c)
{ //Implement the code here }
}
Implementation:

104. Builder Pattern (cont…)
//Concrete Builder
class ASCIIConverter extends TextConverter
{
ASCIIText asciiTextObj; //resulting product
/*converts a character to target representation and appends to the resulting
object*/
void convertCharacter(char c)
{
char asciiChar = new Character(c).charValue();
//gets the ascii character
asciiTextObj.append(asciiChar);
}
void convertParagraph() {}
ASCIIText getResult()
{
return asciiTextObj;
}
}

105. Builder Pattern (cont…)
//This class abstracts the document object
class Document
{
static int value;
char token;
public char getNextToken()
{
//Get the next token
return token;
}
}

106. Builder Pattern (cont…)
//Director
class RTFReader
{
private static final char EOF='0'; //Delimitor for End of File
final char CHAR='c';
final char PARA='p';
char t;
TextConverter builder;
RTFReader(TextConverter obj)
{
builder=obj;
}

107. Builder Pattern (cont…)
void parseRTF(Document doc)
{
while ((t=doc.getNextToken())!= EOF)
{
switch (t)
{
case CHAR: builder.convertCharacter(t);
case PARA: builder.convertParagraph();
}
}
}
}

108. Builder Pattern (cont…)
//Client
public class Client
{
void createASCIIText(Document doc)
{
ASCIIConverter asciiBuilder = new ASCIIConverter();
RTFReader rtfReader = new RTFReader(asciiBuilder);
rtfReader.parseRTF(doc);
ASCIIText asciiText = asciiBuilder.getResult();
}
public static void main(String args[])
{
Client client=new Client();
Document doc=new Document();
client.createASCIIText(doc);
system.out.println("This is an example of Builder Pattern");
}
}

109. Builder Pattern (cont…)
Real World Example
Waiter

110. Prototype Pattern
• To specify the kinds of objects to create using a prototypical
instance, and create new objects by copying this prototype.

111. Prototype Pattern (cont…)

112. Prototype Pattern (cont…)
Participants:
• Client - creates a new object by asking a prototype
to clone itself.
• Prototype - declares an interface for cloning itself.
• ConcretePrototype - implements the operation for
cloning itself.

113. Prototype Pattern (cont…)
Implementation
abstract class AbstractProduct implements Cloneable
{
public static AbstractProduct thePrototype;
public static AbstractProduct makeProduct()
{
try
{
return (AbstractProduct) thePrototype.clone();
}
catch(CloneNotSupportedException e)
{
return null;
}
}
}

114. Prototype Pattern (cont…)
class ConcreteProductA extends AbstractProduct { }
class ConcreteProductB extends AbstractProduct { }
public class PrototypeDemo
{
public static void main(String[] args)
{
AbstractProduct.thePrototype = new ConcreteProductA();
AbstractProduct product = AbstractProduct.makeProduct();
System.out.println(product);
}
}

115. Prototype Pattern (cont…)
Real World Example