Prototype Design Pattern




Intent

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

Explanation

Prototype pattern is one of the Creational Design patterns, so it provides a mechanism of object creation. Prototype pattern is used when the Object creation is a costly affair and requires a lot of time and resources and you have a similar object already existing. So this pattern provides a mechanism to copy the original object to a new object and then modify it according to our needs. This pattern uses java cloning to copy the object. 

It would be easy to understand this pattern with an example, suppose we have an Object that loads data from the database. Now we need to modify this data in our program multiple times,  so it ’s not a good idea to create the Object using new keyword and load all the data again from the database. So the better approach is to clone the existing object into a new object and then do the data manipulation. 

Prototype design pattern mandates that the Object which you are copying should provide the copying feature. It should not be done by any other class. However whether to use a shallow or deep copy of the Object properties depends on the requirements and it ’s a design decision.

Wikipedia says

The prototype pattern is a creational design pattern in software development. It is used when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects.

In short, it allows you to create a copy of an existing object and modify it to your needs, instead of going through the trouble of creating an object from scratch and setting it up.

Structure

Participants

1. Prototype
     - declares an interface for cloning itself.
2. ConcretePrototype
     - implements an operation for cloning itself.
3. Client
     - creates a new object by asking a prototype to clone itself.

Collaborations

  - A client asks a prototype to clone itself. 

Source Code

In Java, it can be easily done by implementing Cloneable and overriding clone from Object.
class Sheep implements Cloneable {
  private String name;
  public Sheep(String name) { this.name = name; }
  public void setName(String name) { this.name = name; }
  public String getName() { return name; }  @Override
  public Sheep clone() throws CloneNotSupportedException {
    return new Sheep(name);
  }
}
Here is the test program that will show the benefit of prototype pattern usage
Sheep original = new Sheep("Jolly");
System.out.println(original.getName()); // Jolly

// Clone and modify what is required
Sheep cloned = original.clone();
cloned.setName("Dolly");
System.out.println(cloned.getName()); // Dolly


Applicability

Use the Prototype pattern when a system should be independent of how its products are created, composed and represented; and
  • when the classes to instantiate are specified at run-time, for example, by dynamic loading.
  • to avoid building a class hierarchy of factories that parallels the class hierarchy of products.
  • when instances of a class can have one of only a few different combinations of state. It may be more convenient to install a corresponding number of prototypes and clone them rather than instantiating the class manually, each time with the appropriate state.
  • when object creation is expensive compared to cloning.

Real world examples

  • java.lang.Object#clone() 
  • Credits 

    The source code of Prototype Pattern on my GitHub repository :

    Comments