0Prototype Design Pattern:
Ø Prototype pattern refers to creating duplicate object while keeping performance in mind.
Ø This pattern involves implementing a prototype interface which tells to create a clone of the current object.
Ø This pattern is used when creation of object directly is costly. For example, an object is to be created after a costly database operation.
Ø We can cache the object, returns its clone on next request and update the database as and when needed thus reducing database calls.
Prototype DP involves cloning of object and thus object needs to:
Ø Implement Cloneable interface
Ø Override clone() of Object class
public abstract class Payment implements Cloneable {
protected double amount;
public double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public abstract void makePayment();
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
public class CreditCard extends Payment {
public void makePayment() {
System.out.println("Payment of "+amount+ " by Credit Card");
}
}
public class CashPayment extends Payment {
public void makePayment() {
System.out.println("Payment of "+amount+" by Cash");
}
}
public class PaymentCache {
private Map<String, Payment> map = new HashMap();
public Payment getPayment(String key) {
Payment payment = map.get(key);
return (Payment) payment.clone();
}
// Map of Objects which are frequently used...
// Original objects are acting as template objects...
public void loadCache() {
CashPayment cash = new CashPayment();
cash.setAmount(2000);
map.put("cash", cash);
CreditCard credit = new CreditCard();
credit.setAmount(4000);
map.put("credit", credit);
}
}
public class Client {
public static void main(String[] args) {
PaymentCache cache= new PaymentCache();
cache.loadCache();
Payment payment=cache.getPayment("cash");
payment.makePayment();
Payment payment1=cache.getPayment("credit");
payment1.makePayment();
}
}
Output:
Payment of 2000.0 by Cash
Payment of 4000.0 by Credit Card
Application:
Session replication from one server to another server.
Generating the GUI having many numbers of similar controls.
Advantage of Prototype Pattern:
It reduces the need of subclassing.
It hides complexities of creating objects.
The clients can get new objects without knowing which type of object it will be.
It lets you add or remove objects at runtime.
Usage of Prototype Pattern:
When the classes are instantiated at runtime.
When the cost of creating an object is expensive or complicated.
When you want to keep the number of classes in an application minimum.
When the client application needs to be unaware of object creation and representation.
