Prototype Design Pattern in Java: Programmer Block

The Prototype design pattern in Java is a creational design pattern that allows you to create new objects by copying existing ones, called prototypes.

This pattern fosters object reusability and provides flexibility in object creation.

How does it work?

The Prototype design pattern is a creational design pattern that allows developers to create new objects by cloning existing ones. Object cloning and object copying are terms used to describe the process of creating a new object that is an identical copy of an existing object. This pattern is useful when creating objects is expensive or time-consuming or when objects need to be created with different states.

Key components

Prototype is the base class that all prototype classes must inherit from. It provides a clone() method to create a copy of an object.
Concrete prototypes: The concrete classes that implement the Prototype interface. They provide the specific implementations of the clone() method to create copies of themselves with the desired state.
Client: The client requests the prototype to clone itself, creating a new object.

How to implement the prototype design pattern in Java

a. Define the prototype abstract class: First, we will create the Prototype class that implements the Cloneable interface. This interface provides a clone() method that can be used to create a copy of the object.

Next, we will override the clone() method and provide an abstract reset() method. Concrete prototype classes can then provide their respective implementations for the reset() method.

public abstract class Department implements Cloneable {

	protected String departmentID = "001";
	protected String departmentName = "TBD";

	public Department(String departmentId, String departmentName) {
		this.departmentID = departmentId;
		this.departmentName = departmentName;
	}

	// overriding cloning method to provide clone objects
	@Override
	protected Department clone() throws CloneNotSupportedException {

		Department dept = (Department) super.clone();
		// initiliaze this object with default or values you want to set
		dept.initialize();
		return dept;
	}

	protected void setDepartmentID(String departID) {
		this.departmentID = departID;
	}

	// this method is to initialize the objects we want to provide in cloning
	private void initialize() {
		this.departmentID = "001";
		this.departmentName = "Unknown";
		resetMethod();
	}

	// abstract method to allow subclass to provide their custom setting to the objects
	public abstract void resetMethod();

	@Override
	public String toString() {
		return "Department [departmentID=" + departmentID + ", departmentName=" + departmentName + "]";
	}

}

b. Create concrete prototype classes: To create new objects using the prototype design pattern, we need to extend the base Prototype class with concrete classes. These concrete classes must implement the reset() method to create copies of themselves with the desired state.

public class ScienceDepartment extends Department {

	private String subjects = "Unknown";

	ScienceDepartment(String subject) {
		super("001", "ScienceDepartment");
		this.subjects = subject;
	}

	@Override
	public String toString() {
		return "ScienceDepartment [subjects=" + subjects + ", departmentID=" + departmentID + ", departmentName="
				+ departmentName + "]";
	}

	@Override
	public void resetMethod() {
		this.subjects = "Unknown";
	}
}

c. The client requests a prototype: By making a request to the concrete prototype, the client can obtain a copy of the prototype object, which initiates the creation of a duplicate object.

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws CloneNotSupportedException {
		ScienceDepartment sDepartment = new ScienceDepartment("Physics");
		sDepartment.setDepartmentID("004");
		System.out.println(sDepartment);
		ScienceDepartment newSDepartment = (ScienceDepartment) sDepartment.clone();
		System.out.println(newSDepartment);
	}

}

d. Verify Output: The Prototype and Concrete Prototype classes initialize the second object, whereas the first object is initialized with the provided values.

ScienceDepartment [ subjects="Physics", departmentID="004", departmentName="ScienceDepartment"]
ScienceDepartment [ subjects="Unknown", departmentID="001", departmentName="Unknown"]

Benefits of using the prototype design pattern in Java

Reduced object creation costs: The Prototype pattern effectively diminishes the expenses related to object creation, particularly for complex objects.
Enhanced performance: Creating new objects through cloning prototypes generally outpaces the creation of objects from scratch.
Flexibility: The pattern provides dynamic object creation, allowing clients to add or remove prototypes at runtime. This flexibility streamlines the object creation process.
Reusability: The pattern encourages using existing objects as prototypes, curbing redundancy, and optimizing the codebase.

Use cases for the prototype design pattern in Java

Creating a pool of objects: We can implement an object pool using the Prototype design pattern. This will allow multiple clients to reuse objects and improve performance by avoiding the need to create new objects each time.
Creating objects with different states: The prototype design pattern allows us to easily create objects with varying states without creating new classes. For instance, we could utilize the prototype design pattern to build a car class that can produce cars with different colors, engine sizes, and other features.
Creating objects based on existing objects: We can use the Prototype design pattern to create objects based on existing objects. For example, we could use the Prototype design pattern to create a class for a document that can be used to create copies of existing documents.

Conclusion

The prototype design pattern is a valuable asset in software design. It champions reusability, trims object creation costs, and amplifies flexibility in object creation. By embracing this pattern, developers can effectively manage object instantiation and elevate the maintainability of their codebase.

Integrating and understanding the prototype pattern can significantly benefit your software development journey, tackling a complex application or a simple utility.

Facebook Tweet Pin LinkedIn Email

Prototype Design Pattern in Java: A Comprehensive Guide