package com.premaseem.prototypePattern;

public abstract class Cell implements Cloneable {

public Cell(){

System.out.println("Constructor of Cell is called ... ");

}

String cellType;

public enum CellProtoTypes{

AMOEBA,BACTERIA,SINGLE_CELL_ORG

}

@Override

protected Object clone() throws CloneNotSupportedException {

// TODO Auto-generated method stub

return super.clone();

}

@Override

public String toString() {

// TODO Auto-generated method stub

return cellType + "with id " + hashCode();

}

public Object split() {

Object cloneCell = null;

try {

cloneCell = this.clone();

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return cloneCell;

}

}

class Amoeba extends Cell{

public Amoeba(){

cellType=" Amoeba ";

System.out.println("Constructor of Amoeba is called ... ");

}

}

class Bacteria extends Cell{

public Bacteria(){

cellType=" Bacteria ";

System.out.println("Constructor of Bacteria is called ... ");

}

}

class SingleCell extends Cell{

public SingleCell(){

cellType=" SingleCell ";

System.out.println("Constructor of SingleCell is called ... ");

}

}

package com.premaseem.prototypePattern;

import java.util.Scanner;

import com.premaseem.prototypePattern.Cell.CellProtoTypes;

public class ClientFile {

public static void main(String[] args) {

System.out.println("Welcome to Prototype design patters Lab ");

Scanner scan = new Scanner(System.in);

SpecimenCache specimenLab = SpecimenCache.getInstance();

Cell subjectCell = null;

int repeatRunFlag = 1;

while (repeatRunFlag == 1) {

// TVInterface tv;

System.out.println("Which organizm you would like to culture / grow / multiply ? ");

System.out.println("press 1 for Single Cell Org");

System.out.println("press 2 for Amoeba ");

System.out.println("press 3 for Bacteria ");

int type = scan.nextInt();

if (type == 1) {

subjectCell = specimenLab.getCellProtoType(CellProtoTypes.SINGLE_CELL_ORG);

} else if (type == 2) {

subjectCell = specimenLab.getCellProtoType(CellProtoTypes.AMOEBA);

} else {

subjectCell = specimenLab.getCellProtoType(CellProtoTypes.BACTERIA);

}

System.out.println("Culture process has started ");

System.out.println(" Cells are spliting/cloning and growing ");

for (int i = 0; i < 10; i++) {

System.out.println(subjectCell.split());

System.out.println(" ........... ........ >>>> .... ");

}

System.out.println("=============================");

System.out.println("Press 1 to Repeat .... ");

repeatRunFlag = scan.nextInt();

}

System.out.println("\n $$$$$$$$$$$$$$$$$$$$ Thanks by Prem Aseem $$$$$$$$$$$$$$$$$$$$$$ \n ");

System.out.println("\n $$$$$$$$$$$$$$$$$$$$$ www.premaseem.com $$$$$$$$$$$$$$$$$$$$$$ \n ");

}

}

Download the working example demo code in java from my GIT repository -https://github.com/premaseem/designPatterns/tree/4bb9beca7bab5b5e71d02b76e4f1ad48fce4aca6/ZipDownloadableProjects

Code Example

The Prototype pattern specifies the kind of objects to create using a prototypical instance. Cell is the abstract class with different subclasses like singleCell Organism, amoeba, bacteria etc. For each sub class a breeder object is created before hand and registered in SpecimenCache.java class. Now whenever client program wants to breed or culture a particular organism say amobea they will fetch it from cache and invoke split/clone method which will provide replicated organism with same state property. Download the example code and have fun.

Example of Prototype

When creating an object is time consuming and a costly affair and you already have a most similar object instance in hand, then you go for prototype pattern. Instead of going through a time consuming process to create a complex object, just copy the existing similar object and modify it according to your needs. Clone the existing instance in hand and then make the required update to the cloned instance so that you will get the object you need. Other way is, tweak the cloning method itself to suit your new object creation need.

Intent

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

Co-opt one instance of a class for use as a breeder of all future instances.

The new operator considered harmful.

Problem

Application "hard wires" the class of object to create in each "new" expression.

Discussion

Declare an abstract base class that specifies a pure virtual "clone" method, and, maintains a dictionary of all "cloneable" concrete derived classes. Any class that needs a "polymorphic constructor" capability: derives itself from the abstract base class, registers its prototypical instance, and implements the clone() operation.

The client then, instead of writing code that invokes the "new" operator on a hard-wired class name, calls a "clone" operation on the abstract base class, supplying a string or enumerated data type that designates the particular concrete derived class desired.

Check list

Add a clone() method to the existing "product" hierarchy.

Design a "registry" that maintains a cache of prototypical objects. The registry could be encapsulated in a new Factory class, or in the base class of the "product" hierarchy.

Design a factory method that: may (or may not) accept arguments, finds the correct prototype object, calls clone() on that object, and returns the result.

The client replaces all references to the new operator with calls to the factory method.

Rules of thumb

Prototype co-opts one instance of a class for use as a breeder of all future instances.

Prototypes are useful when object initialization is expensive, and you anticipate few variations on the initialization parameters. In this context, Prototype can avoid expensive "creation from scratch", and support cheap cloning of a pre-initialized prototype.

Factory Method: creation through inheritance. Protoype: creation through delegation.

Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward Abstract Factory, Protoype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed.

Prototype doesn't require subclassing, but it does require an "initialize" operation. Factory Method requires subclassing, but doesn't require Initialize.

Designs that make heavy use of the Composite and Decorator patterns often can benefit from Prototype as well.

package com.premaseem.prototypePattern;

import java.util.EnumMap;

import java.util.Map;

import com.premaseem.prototypePattern.Cell.CellProtoTypes;

public class SpecimenCache {

static SpecimenCache specimenCache=null;

private Map<CellProtoTypes,Cell> prototypeSamples = new EnumMap<CellProtoTypes,Cell>(CellProtoTypes.class);

static public SpecimenCache getInstance(){

if(specimenCache==null){

specimenCache = new SpecimenCache();

}

return specimenCache;

}

public SpecimenCache(){

loadSpecimenCache();

}

void loadSpecimenCache(){

prototypeSamples.put(CellProtoTypes.SINGLE_CELL_ORG, new SingleCell());

prototypeSamples.put(CellProtoTypes.BACTERIA, new Bacteria());

prototypeSamples.put(CellProtoTypes.AMOEBA, new Amoeba());

}

public Cell getCellProtoType(CellProtoTypes cell){

return prototypeSamples.get(cell);

}

}