11.3.5. Prototype Pattern

The Prototype Pattern is used to create duplicate objects while keeping performance in mind.

The Prototype Pattern allows for the creation of new objects by copying an existing object rather than creating a new instance from scratch. This is particularly useful when the cost of creating a new object is high or when the object needs to be created in a similar state to an existing one.

Imagine you are painting a large mural. Instead of drawing the entire mural from scratch every time you want a new one, you take a high-quality photograph of the finished mural. You can then use that photograph to recreate the mural style and colors swiftly without starting over. This is similar to how the Prototype Pattern works; it uses a ‘copy’ of an object rather than creating a new one from the ground up.

The Prototype class typically implements the Cloneable interface and overrides the clone() method to enable object duplication.

In Java, to support the Prototype Pattern, the object that needs to be duplicated must implement the Cloneable interface. This signifies that the object can be cloned. The clone() method, which is inherited from the Object class, is overridden to provide the cloning functionality. When this method is called on an instance, it creates and returns a new instance that is a copy of the original.

Think about a teacher who has a master copy of a test paper. Instead of writing each test out individually, they make photocopies of the master copy. Each photocopy is a clone of the master and can be distributed to students. This process of creating new copies of a specific object is akin to using the clone() method in the Prototype Pattern.

Here is a simple implementation of the Prototype Pattern in Java:

class Shape implements Cloneable {
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

In this Java code, we have a class named Shape that implements the Cloneable interface. The method clone() is overridden to call super.clone(). By doing this, any instance of the Shape class can be cloned, meaning that its values and states can be copied to create a new instance without explicitly defining what to copy every time.

Consider a high-quality printer that can duplicate any printed document flawlessly. By using this printer, you take the original document, press a button, and receive an exact copy. This represents the Prototype Pattern, where the job of creating new instances—via cloning—is simplified and efficient, similar to how the printer does with documents.

--