Prototype Design Pattern

In this post, we will learn how to implement the Prototype Design Pattern in Java with step by step example.

Prototype Design Pattern specifies the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

Understanding Prototype Design Pattern

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

Class Diagram

  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.

Prototype Design Pattern Implementation in Java

In Java, it can be easily done by implementing Cloneable and overriding clone from Object.

Let's create Sheep class which implements Cloneable interface:

class Sheep implements Cloneable {
    private String name;
    public Sheep(String name) { = name;
    public void setName(String name) { = name;
    public String getName() {
        return name;
    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();
System.out.println(cloned.getName()); // Dolly


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