Desing pattern prototype-Factory Method, Prototype and Builder

Design Pattern
Introduction
Factory Method, Prototype & Builder Design
Pattern
-ParamiSoft Systems Pvt. Ltd.

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

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

Factory Method

• 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

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.

Factory Says
Define an interface for creating an object, but let
subclasses decide which class to instantiate

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

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"; } }

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());
}
}

• 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

Prototype Design Pattern

Prototype Design Pattern
Specify the kinds of objects to
create using a prototypical
instance, and create new objects
by copying this prototype

Structure

Applicability
• 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.

Consequences
• 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.

Psudocode
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

Psudocode
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()

Builder Design Pattern

• 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

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

Psudocode
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.

Psudocode
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()

Discussion
• 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.

References
Links
o http://en.wikipedia.org/wiki/Factory_method_pattern
o http://en.wikipedia.org/wiki/Prototype_pattern
o http://en.wikipedia.org/wiki/Builder_pattern
o http://sourcemaking.com/design_patterns
Links
o Design Patterns in Ruby – Russ Olsen
o Head First Design Patterns – Elisabeth Freeman, Eric Freeman, Bert Bates and Kathy
Sierra

If(Questions)
{
Ask;
}
else
{
Thank you;
}

Desing pattern prototype-Factory Method, Prototype and Builder

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Destaque

Destaque (20)

Semelhante a Desing pattern prototype-Factory Method, Prototype and Builder

Semelhante a Desing pattern prototype-Factory Method, Prototype and Builder (20)

Mais de paramisoft

Mais de paramisoft (7)

Último

Último (20)

Desing pattern prototype-Factory Method, Prototype and Builder