Prototype Design Pattern

Added: 2026-05-11

[00:00:00]Explain the prototype design pattern.

[00:00:03]The prototype design pattern is a creational design pattern that allows you to create new objects by copying an existing object, also known as cloning.

[00:00:13]Instead of creating new objects from scratch using the new keyword, the prototype pattern creates objects by duplicating an existing instance that already has the required configuration.

[00:00:26]This approach is extremely useful when object creation is expensive, complex or time consuming. For example, objects loaded from a database, objects created after heavy computation or objects with multiple dependencies.

[00:00:42]The prototype pattern solves this problem by letting you take an existing object and clone it, producing a brand new instance with the same state.

[00:00:52]The main idea is simple. Instead of rebuilding, you reuse the structure and only adjust the parts you need. Now let's understand this with a very clear and practical demonstration.

[00:01:04]We will build a shape system where shapes like circle and rectangle can be cloned using the prototype pattern.

[00:01:12]Here is the complete working example.

[00:01:14]We begin by creating an interface named prototype. This interface declares a method called clone which is responsible for creating a copy of the object. Next, we create a class called circle that implements the prototype interface. The circle class contains two fields, radius and color.

[00:01:35]Inside the clone method, we return a new circle object and pass the current radius and color values to the constructor. This ensures that the new object is an exact copy of the existing one.

[00:01:48]Then we create another class rectangle with fields width, height and color.

[00:01:54]Rectangle also implements the prototype interface and its clone method returns a new rectangle with the same width, height and color values.

[00:02:03]Inside the main class, we create our first circle with radius 10 and color red. This is the original object. Next, we call c1.clone and cast the result to circle.

[00:02:16]This creates C2 which is a copy of C1.

[00:02:20]Both have the same radius and the same color but they are separate objects in memory. Then we repeat the same process for the rectangle class. We create R1 with width five height 8 and color blue.

[00:02:35]Then we clone it to get R2.

[00:02:38]When we call the show method on both C1 and C2, we see identical values proving that C2 is a clone of C1.

[00:02:48]Similarly, R1 and R2 print identical values showing the same clone result.

[00:02:54]Let's run the program. In the console, you can see the original and cloned object are same.

[00:03:02]This demonstration clearly shows how the prototype pattern creates new objects by copying the existing ones instead of constructing them from scratch.

[00:03:12]Now let's see when should you use the prototype pattern.

[00:03:16]Use the prototype pattern when object creation is expensive. For example, loading objects from a database, reading configuration files, connecting to external services, or doing heavy calculations just to build an object.

[00:03:33]Instead of repeating expensive initialization, you create one fully configured object and clone it whenever needed.

[00:03:42]Use it when the system needs many copies of similar objects, but with small differences.

[00:03:49]Use it when your object or structure is complex and contains many fields that would be difficult to pass through constructors.

[00:03:58]Here is the final answer you can confidently speak in your interview.

[00:04:03]The prototype design pattern is a creational pattern used to create new objects by cloning existing ones. It is useful when object creation is expensive or complex.

[00:04:13]Instead of using the new keyword every time, you clone an existing object and customize it if required.

[00:04:21]It improves performance, reduces complexity, and keeps object creation logic centralized.

[00:04:28]In real systems, prototype is used for document templates, UI components, configuration objects, database loaded objects, and any scenario where repeated construction is costly.

[00:04:41]That is the complete explanation of the prototype design pattern.