// Tutorial //

Prototype Design Pattern in Java

Published on August 3, 2022
Default avatar
By Pankaj
Developer and author at DigitalOcean.
Prototype Design Pattern in Java

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Prototype design pattern is one of the Creational Design pattern, so it provides a mechanism of object creation.

Prototype Design Pattern

prototype design pattern Prototype design 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. Prototype pattern provides a mechanism to copy the original object to a new object and then modify it according to our needs. Prototype design pattern uses java cloning to copy the object.

Prototype Design Pattern Example

It would be easy to understand prototype design pattern with an example. Suppose we have an Object that loads data from 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 database. The better approach would be 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 shallow or deep copy of the Object properties depends on the requirements and its a design decision. Here is a sample program showing Prototype design pattern example in java. Employees.java

package com.journaldev.design.prototype;

import java.util.ArrayList;
import java.util.List;

public class Employees implements Cloneable{

	private List<String> empList;
	
	public Employees(){
		empList = new ArrayList<String>();
	}
	
	public Employees(List<String> list){
		this.empList=list;
	}
	public void loadData(){
		//read all employees from database and put into the list
		empList.add("Pankaj");
		empList.add("Raj");
		empList.add("David");
		empList.add("Lisa");
	}
	
	public List<String> getEmpList() {
		return empList;
	}

	@Override
	public Object clone() throws CloneNotSupportedException{
			List<String> temp = new ArrayList<String>();
			for(String s : this.getEmpList()){
				temp.add(s);
			}
			return new Employees(temp);
	}
	
}

Notice that the clone method is overridden to provide a deep copy of the employees list. Here is the prototype design pattern example test program that will show the benefit of prototype pattern. PrototypePatternTest.java

package com.journaldev.design.test;

import java.util.List;

import com.journaldev.design.prototype.Employees;

public class PrototypePatternTest {

	public static void main(String[] args) throws CloneNotSupportedException {
		Employees emps = new Employees();
		emps.loadData();
		
		//Use the clone method to get the Employee object
		Employees empsNew = (Employees) emps.clone();
		Employees empsNew1 = (Employees) emps.clone();
		List<String> list = empsNew.getEmpList();
		list.add("John");
		List<String> list1 = empsNew1.getEmpList();
		list1.remove("Pankaj");
		
		System.out.println("emps List: "+emps.getEmpList());
		System.out.println("empsNew List: "+list);
		System.out.println("empsNew1 List: "+list1);
	}

}

Output of the above prototype design pattern example program is:

emps List: [Pankaj, Raj, David, Lisa]
empsNew List: [Pankaj, Raj, David, Lisa, John]
empsNew1 List: [Raj, David, Lisa]

If the object cloning was not provided, we will have to make database call to fetch the employee list every time. Then do the manipulations that would have been resource and time consuming. That’s all for prototype design pattern in java.


Want to learn more? Join the DigitalOcean Community!

Join our DigitalOcean community of over a million developers for free! Get help and share knowledge in our Questions & Answers section, find tutorials and tools that will help you grow as a developer and scale your project or business, and subscribe to topics of interest.

Sign up
About the authors
Default avatar
Pankaj

author

Developer and author at DigitalOcean.

Still looking for an answer?

Was this helpful?

Beautiful and easy to understand !, thanks

- Ajay

    Very useful example of the prototype to help my understanding While not Java, I have created a video tutorial of the Protoype pattern in python that is getting a good response. https://youtu.be/\_jBjhI6-VDI

    - SeanWasere YTBE

      Hi, Why do you implement Cloneable interface and override clone method? You are using new operator which will give you a new memory address where you copy all the elements from the old structure. Do we relly need to implement this interface in this case?

      - Adrian

        Hi, You mentioned that creating an object using a new operator is costly. But in your code you are still using new method to deep clone the object. Then what is the difference between the traditional way of creation and creation using prototype? Thanks

        - Thejus Singh Jagadish

          The Clone method still use new to correct object. it does not meet the design pattern requirement. “Prototype design 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.” It do save time to get data from DB. Is below clone method better? @Override protected Object clone() throws CloneNotSupportedException { Object ee = (Employees)super.clone(); List tmp = new ArrayList(); ((Employees) ee).setEmpList(tmp); for(String s: this.empList) tmp.add(s); return ee; }

          - Ying Zhang

            Thanks! Very useful

            - Amine KOUIS

              Hi Pankaj, Could you please provide JDK example as well for prototype design pattern?

              - Ganesh AC

                Thanks, very nice expl

                - Arun SIngh

                  Dear Pankaj, I was experimenting with the code you provided here. Found something really weird that I couldn’t understand. Please check the following method. @Override public Object clone() throws CloneNotSupportedException { return new PlayersList(empList); } Instead of returning the ‘temp’ ArrayList, I returned the ‘empList’. output like this: emps HashMap : [Pankaj, Raj, David, Lisa] empsNew HashMap : [Raj, David, Lisa, John] empsNew1 HashMap : [Raj, David, Lisa, John] I think there is something that I have failed to understand. An explanation would be of great help. Thanks a lot for these nice, useful and easy to implement tutorials.

                  - Tahmid

                    what is use of implementing Cloneable interface in this example and suppose i removed cloneable interface then what will happened.it will clone object,i tried to remove cloneable interface but same output came,please explain

                    - salil