factory method & strategy pattern
TRANSCRIPT
![Page 1: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/1.jpg)
Factory Method PatternStrategy Pattern
Proxy Pattern
![Page 2: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/2.jpg)
2
Factory Method(Creational)
![Page 3: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/3.jpg)
3
Factory MethodName: Factory MethodIntent: 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.
![Page 4: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/4.jpg)
4
Basic Structure
Product is the interface for the type of object that the Factory Method creates. Creator is the interface that defines the Factory Method.
Product<<<interface>>>
ConcreteProduct
Creator
FactoryMethod()
<<<interface>>>
ConcreteCreator
FactoryMethod()
<<instantiates>>
![Page 5: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/5.jpg)
5
A Case Study: Database Connections
You want to connect to a database but you want to decide at run time which type of database it is (i.e. SQL, Oracle, MySQL etc.)
Apply Factory Method
![Page 6: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/6.jpg)
6
Structure of Case study
ConnectionFactory
createConnection() : Connection
<<<interface>>>
MyConnectionFactory
createConnection() : Connection
Connection
description()open()close()
<<<interface>>>
SQLConnection MySQLConnection OracleConnection<<instantiates>>
Instantiates SQLConnection / MySQLConnection / OracleConnection
![Page 7: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/7.jpg)
7
Implementation: ConnectionFactory
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(); }
}}
![Page 8: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/8.jpg)
8
Implementation: Connection
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"; } }
These three implementing classes should have definition for Open & Close Methods of above interface as well to be concrete.
![Page 9: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/9.jpg)
9
Implementation: TestConnectionFactory
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());}
}
![Page 10: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/10.jpg)
10
Strategy Pattern
![Page 11: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/11.jpg)
11
Strategy Pattern
Name: StrategyIntent: Define a family of algorithms,
encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
Problem: How to design for varying, but related, algorithms or policies?
Solution: Define each algorithm/policy/strategy in a separate class, with a common interface.
![Page 12: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/12.jpg)
12
Basic Structure
ConcreteStrategyA ConcreteStrategyB
ContextStrategy
Algorithm()
![Page 13: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/13.jpg)
13
Participants
Strategy : declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a ConcreteStrategy.
ConcreteStrategy: implements the algorithm using the Strategy interface.
Context : is configured with a ConcreteStrategy object. maintains a reference to a Strategy object. may define an interface that lets Strategy
access its data.
![Page 14: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/14.jpg)
14
Case StudyWe are developing an e-commerce application
where we need to calculate Tax…there are two tax strategies…Tax rate is 10% for old citizens and 15% otherwise.
![Page 15: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/15.jpg)
15
Case Study Structure
Citizen OldCitizen
TaxStrategy
calcTax()
<<<interface>>>
ClientTaxContext
setStrategy() : TaxStrategycalculateTax()
![Page 16: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/16.jpg)
16
Implementation: TaxStrategy
public interface TaxStrategy{public void calcTax();
}class Citizen implements TaxStrategy{
public void calcTax(){System.out.println("Tax Deduction @
15%");}}
class OldCitizen implements TaxStrategy{public void calcTax(){
System.out.println("Tax Deduction @ 10%");}}
![Page 17: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/17.jpg)
17
Implementation: TaxContext
class TaxContext{
private TaxStrategy TS;
public void setStrategy(TaxStrategy ts){ TS=ts; }
public void calculateTax(){ TS.calcTax(); }}
class Client{
public static void main(String[]args){
TaxContext cont = new TaxContext();
cont.setStrategy(new Citizen());
cont.calculateTax();
}
}
![Page 18: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/18.jpg)
18
How to Create Strategies
There are different Taxing algorithms or strategies, and they change over time. Who should create the strategy?
A straightforward approach is to apply the Factory pattern
![Page 19: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/19.jpg)
19
Strategy and Factory Method
Product<<<interface>>>
ConcreteProduct
Creator
FactoryMethod()
<<<interface>>>
ConcreteCreator
FactoryMethod()
<<instantiates>>
ConcreteStrategyA ConcreteStrategyB
Strategy
Algorithm()
Context
![Page 20: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/20.jpg)
20
Case Study Structure
StrategyFactory
getStrategy() : TaxStrategy
<<<interface>>>
MyStrategyCitizen OldCitizen
TaxStrategy
calcTax()
<<<interface>>>TaxContext
setStrategy() : TaxStrategycalculateTax()
Client
<<instantiates>>
![Page 21: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/21.jpg)
21
Implementation: StrategyFactorypublic interface StrategyFactory{
public TaxStrategy getStrategy();
}
class MyStrategy implements StrategyFactory{
String type;
public MyStrategy(String t){ type=t; }
public TaxStrategy getStrategy(){
if(type.equals("Citizen"))
return new Citizen();
else
return new OldCitizen();} }
![Page 22: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/22.jpg)
22
Implementation: Clientclass Client{
public static void main(String[]args){MyStrategy m = new
MyStrategy("Citizen");TaxContext cont = new TaxContext();cont.setStrategy(m.getStrategy());cont.calculateTax();
}}
![Page 23: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/23.jpg)
23
Proxy Pattern
![Page 24: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/24.jpg)
24
Proxy Pattern
Name: ProxyIntent: Provide a surrogate or placeholder for
another object to control access to it.Problem: You want to control the access to an
object for different reasons. You may want to delay the creation / initialization of expensive objects or you may want to provide a local representation of a remote object.
Solution: Provide a Stub / placeholder for actual object.
![Page 25: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/25.jpg)
25
Basic Structure
Client Subject
someOperation()
<<<interface>>>
Proxy
someOperation()
RealSubject
someOperation()
RealSubject someOperation()
![Page 26: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/26.jpg)
26
ParticipantsSubject - Interface implemented by the
RealSubject and representing its services. The interface must be implemented by the proxy as well so that the proxy can be used in any location where the RealSubject can be used.
Proxy- Maintains a reference that allows the Proxy to access the RealSubject. Implements the same interface implemented by the RealSubject so that the Proxy can be substituted for the RealSubject. Controls access to the RealSubject and may be responsible for its creation and deletion.
RealSubject- the real object that the proxy represents.
![Page 27: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/27.jpg)
27
Case Study
Consider an image viewer program that lists and displays high resolution photos. The program has to show a list of all photos however it does not need to display the actual photo until the user selects an image item from a list.
![Page 28: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/28.jpg)
28
Case Study Structure
ProxyImage
showImage() : void
HRImage
showImage() : void
ImageViewer Image
showImage() : void
<<<interface>>>
showImage() displays the Image only when needed
![Page 29: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/29.jpg)
29
Implementation: Imagepublic interface Image{
public void showImage();
}
class HRImage implements Image{
public HRImage(){
System.out.println("loading a High Resolution image");
}
public void showImage(){
System.out.println("Showing a High Resolution Image");
}
}
![Page 30: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/30.jpg)
30
Implementation: ProxyImageclass ProxyImage implements Image{
private Image proxyImage;public ProxyImage(){ System.out.println("Loading a proxy image");}public void showImage(){
proxyImage = (HRImage)new HRImage();proxyImage.showImage();} }
class ImageViewer{public static void main(String[]args){
Image HRImage1 = new ProxyImage();Image HRImage2 = new ProxyImage();Image HRImage3 = new ProxyImage();
HRImage1.showImage();} }
![Page 31: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/31.jpg)
31
Applicability
Virtual Proxies: delaying the creation and initialization of expensive objects until needed, where the objects are created on demand
Remote Proxies: providing a local representation for an object that is in a different address space. A common example is Java RMI stub objects. The stub object acts as a proxy where invoking methods on the stub would cause the stub to communicate and invoke methods on a remote object (called skeleton) found on a different machine.
Protection Proxies: where a proxy controls access to RealSubject methods, by giving access to some objects while denying access to others.
![Page 32: Factory method & strategy pattern](https://reader034.vdocuments.net/reader034/viewer/2022051400/558c07a9d8b42a473a8b461a/html5/thumbnails/32.jpg)
32
The End