The document discusses three design patterns: Factory Method, Prototype, and Builder. Factory Method defines an interface for creating objects but lets subclasses decide which class to instantiate. Prototype specifies the kinds of objects to create using a prototypical instance that new objects can be cloned from. Builder separates the construction of a complex object from its representation so that the same construction process can create different representations.
2. Agenda
• Factory Method Pattern
o Introduction
o When to consider?
o Example
o Limitations
Prototype Pattern
o Introduction
o Applicability
o Consequences
o Example
Prototype Pattern
o Introduction
o Example
o Discussion
-ParamiSoft Systems Pvt. Ltd.
3. The Gang of Four: Pattern Catalog
Creational
Abstract Factory
Builder
Factory Method
Prototype
Singleton
Structural
Adapter
Bridge
Composite
Decorator
Façade
Flyweight
Proxy
Behavioral
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor
Patterns in red we will
discuss in this presentation
-ParamiSoft Systems Pvt. Ltd.
5. -ParamiSoft Systems Pvt. Ltd.
• Name: Factory Method
• Intent: Define an interface for creating an object,
but let subclasses decide which class to instantiate.
Defer instantiation to subclasses.
• Problem: A class needs to instantiate a derivation of
another class, but doesn't know which one. Factory
Method allows a derived class to make this
decision.
• Solution: Provides an abstraction or an interface
and lets subclass or implementing classes decide
which class or method should be instantiated or
called, based on the conditions or parameters
given.
Factory Method
6. -ParamiSoft Systems Pvt. Ltd.
When to consider?
• When we have a class that implements an
interface but not sure which object, which
concrete instantiation / implementation need to
return.
• When we need to separate instantiation from the
representation.
• When we have lots of select and switch
statements for deciding which concrete class to
create and return.
7. -ParamiSoft Systems Pvt. Ltd.
Factory Says
Define an interface for creating an object, but let
subclasses decide which class to instantiate
8. -ParamiSoft Systems Pvt. Ltd.
public interface ConnectionFactory{
public Connection createConnection();
}
class MyConnectionFactory implements ConnectionFactory{
public String type;
public MyConnectionFactory(String t){
type = t; }
public Connection createConnection(){
if(type.equals("Oracle")){
return new OracleConnection(); }
else if(type.equals("SQL")){
return new SQLConnection(); }
else{ return new MySQLConnection(); }
}
}
Implementation: ConnectionFactory
9. -ParamiSoft Systems Pvt. Ltd.
public interface Connection{
public String description();
public void open();
public void close();
}
class SQLConnection implements Connection{
public String description(){ return "SQL";} }
class MySQLConnection implements Connection{
public String description(){ return "MySQL” ;} }
class OracleConnection implements Connection{
public String description(){ return "Oracle"; } }
Implementation: ConnectionFactory
10. -ParamiSoft Systems Pvt. Ltd.
class TestConnectionFactory{
public static void main(String[]args){
MyConnectionFactory con = new
MyConnectionFactory("My SQL");
Connection con2 = con.createConnection();
System.out.println("Connection Created: ");
System.out.println(con2.description());
}
}
Implementation: ConnectionFactory
11. -ParamiSoft Systems Pvt. Ltd.
• Refactoring an existing class to use factories breaks
existing clients.
• Since the pattern relies on using a private
constructor, the class cannot be extended
• if the class were to be extended (e.g., by making
the constructor protected—this is risky but feasible),
the subclass must provide its own re-implementation
of all factory methods with exactly the same
signatures.
Limitations
13. Prototype Design Pattern
Specify the kinds of objects to
create using a prototypical
instance, and create new objects
by copying this prototype
-ParamiSoft Systems Pvt. Ltd.
15. Applicability
-ParamiSoft Systems Pvt. Ltd.
• Avoid subclasses of an object creator in the client
application
• Avoid the inherent cost of creating new object in
the standard way eg. Using new keyword
• Alternative to Factory Method and Abstract
Factory.
• Can be used to implement Abstract Factory.
• To avoid building a class hierarchy of factories.
• Can be used when loading classes dynamically
• Often can use class objects instead.
16. Consequences
-ParamiSoft Systems Pvt. Ltd.
• Add/Remove prototypes at runtime.
• Specify new prototypes by varying data.
• Specify new prototypes by varying
structure.
• Less classes (less sub-classing!)
• Dynamic class loading.
17. Psudocode
-ParamiSoft Systems Pvt. Ltd.
class WordOccurrences is
field occurrences is
The list of the index of each occurrence of the word in the text.
constructor WordOccurrences(text, word) is
input: the text in which the occurrences have to be found
input: the word that should appear in the text
Empty the occurrences list
for each textIndex in text
isMatching := true
for each wordIndex in word
if the current word character does not match the current text character then
isMatching := false
if isMatching is true then
Add the current textIndex into the occurrences list
18. Psudocode
-ParamiSoft Systems Pvt. Ltd.
method getOneOccurrenceIndex(n) is
input: a number to point on the nth occurrence.
output: the index of the nth occurrence.
Return the nth item of the occurrences field if any.
method clone() is
output: a WordOccurrences object containing the same data.
Call clone() on the super class.
On the returned object, set the occurrences field with the value of the local
occurrences field.
Return the cloned object.
text := "The prototype pattern is a creational design pattern in software
development first described in design patterns, the book."
word := "pattern"
searchEngine := new WordOccurrences(text, word)
anotherSearchEngine := searchEngine.clone()
20. -ParamiSoft Systems Pvt. Ltd.
• Name: Builder
• Intent: The intent of the Builder design pattern is to
separate the construction of a complex object from
its representation. By doing so, the same
construction process can create different
representations
Builder
21. -ParamiSoft Systems Pvt. Ltd.
The builder pattern is an object creation design
pattern. Unlike the abstract factory and factory
method pattern whose intention is to enable
polymorphism, the intention of the builder pattern is to
find a solution to the telescoping constructor anti-
pattern. The telescoping constructor anti-pattern
occurs when the increase of object constructor
parameter combinations leads to an exponential list
of constructors. Instead of using numerous
constructors, the builder pattern user another object.
A builder that receives each initialization parameter
step by step and then returns the resulting constructed
object at once
Description
22. Psudocode
-ParamiSoft Systems Pvt. Ltd.
class Car is
Can have GPS, trip computer and various numbers of seats. Can be a city car, a
sports car, or a cabriolet.
class CarBuilder is
method getResult() is
output: a Car with the right options
Construct and return the car.
method setSeats(number) is
input: the number of seats the car may have.
Tell the builder the number of seats.
method setCityCar() is
Make the builder remember that the car is a city car.
method setCabriolet() is
Make the builder remember that the car is a cabriolet.
method setSportsCar() is
Make the builder remember that the car is a sports car.
23. Psudocode
-ParamiSoft Systems Pvt. Ltd.
method setTripComputer() is
Make the builder remember that the car has a trip computer.
method unsetTripComputer() is
Make the builder remember that the car does not have a trip computer.
method setGPS() is
Make the builder remember that the car has a global positioning system.
method unsetGPS() is
Make the builder remember that the car does not have a global positioning
system.
Construct a CarBuilder called carBuilder
carBuilder.setSeats(2)
carBuilder.setSportsCar()
carBuilder.setTripComputer()
carBuilder.unsetGPS()
car := carBuilder.getResult()
24. Discussion
-ParamiSoft Systems Pvt. Ltd.
• Factory Method: delegate to subclasses.
• AbstractFactory, Builder, and Prototype:
delegate to another class.
• Prototype: reduces the total number of
classes.
• Builder: Good when construction logic is
complex.