The document describes the Factory Method design pattern. It defines an interface for creating an object, but lets subclasses decide which class to instantiate. This allows a class to instantiate a derivation of another class without knowing the exact class. The document provides an example of using the Factory Method pattern to create different types of database connections at runtime depending on the database type.

2. 2

3. 3
 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.

4. 4
Product is the interface for the type of object that the Factory Method
creates. Creator is the interface that defines the Factory Method.

5. 5
 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

6. 6

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

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

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

10. 10

11. 11
 Name: Strategy
 Intent: 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.

12. 12

13. 13
 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.

14. 14
 We 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.

15. 15

16. 16
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%");}}

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

18. 18
 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

19. 19

20. 20

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

22. 22
class Client{
public static void main(String[]args){
MyStrategy m = new MyStrategy("Citizen");
TaxContext cont = new TaxContext();
cont.setStrategy(m.getStrategy());
cont.calculateTax();
}
}

23. 23

24. 24
 Name: Proxy
 Intent: 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.

25. 25

26. 26
 Subject - 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.

27. 27
 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.

28. 28

29. 29
public 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");
}
}

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

31. 31
 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.

32. 32