Prototype pattern


The prototype pattern is a creational design pattern in software development. It is used when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used to:
To implement the pattern, declare an abstract base class that specifies a pure virtual clone method. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone operation.
The client, instead of writing code that invokes the "new" operator on a hard-coded class name, calls the clone method on the prototype, calls a factory method with a parameter designating the particular concrete derived class desired, or invokes the clone method through some mechanism provided by another design pattern.
The mitotic division of a cell — resulting in two identical cells — is an example of a prototype that plays an active role in copying itself and thus, demonstrates the Prototype pattern. When a cell splits, two cells of identical genotype result. In other words, the cell clones itself.

Overview

The Prototype
design pattern is one of the twenty-three well-known
GoF design patterns
that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.
The Prototype design pattern solves problems like:
Creating objects directly within the class that requires the objects
is inflexible because it commits the class to particular objects at compile-time and makes it impossible to specify which objects to create at run-time.
The Prototype design pattern describes how to solve such problems:
This enables configuration of a class with different Prototype objects, which are copied to create new objects, and even more, Prototype
objects can be added and removed at run-time.
See also the UML class and sequence diagram below.

Structure

UML class and sequence diagram

In the above UML class diagram,
the Client class that requires a Product object doesn't instantiate the Product1 class directly.
Instead, the Client refers to the Prototype interface for cloning an object.
The Product1 class implements the Prototype interface by creating a copy of itself.
The UML sequence diagram shows the run-time interactions:
The Client object calls clone on a prototype:Product1 object, which creates and returns a copy of itself.

UML class diagram

Rules of thumb

Sometimes creational patterns overlap — there are cases when either prototype or abstract factory would be appropriate. At other times they complement each other: abstract factory might store a set of prototypes from which to clone and return product objects. Abstract factory, builder, and prototype can use singleton in their implementations.. Abstract factory classes are often implemented with factory methods, but they can be implemented using prototype.
Often, designs start out using Factory Method and evolve toward abstract factory, prototype, or builder as the designer discovers where more flexibility is needed.
Prototype does not require subclassing, but it does require an "initialize" operation. Factory method requires subclassing, but does not require initialization.
Designs that make heavy use of the composite and decorator patterns often can benefit from Prototype as well.
The rule of thumb could be that you would need to clone an Object when you want to create another Object at runtime that is a true copy of the Object you are cloning. True copy means all the attributes of the newly created Object should be the same as the Object you are cloning. If you could have instantiated the class by using new instead, you would get an Object with all attributes as their initial values.
For example, if you are designing a system for performing bank account transactions, then you would want to make a copy of the Object that holds your account information, perform transactions on it, and then replace the original Object with the modified one. In such cases, you would want to use clone instead of new.

Code samples

Pseudocode

Let's write an occurrence browser class for a text. This class lists the occurrences of a word in a text. Such an object is expensive to create as the locations of the occurrences need an expensive process to find. So, to duplicate such an object, we use the prototype pattern:
class WordOccurrences is
field occurrences is
The list of the index of each occurrence of the word in the text.
constructor WordOccurrences is
input: the text in which the occurrences have to be found
input: the word that should appear in the text
Empty the occurrences list
for each textIndex in text
isMatching := true
for each wordIndex in word
if the current word character does not match the current text character then
isMatching := false
if isMatching is true then
Add the current textIndex into the occurrences list
method getOneOccurrenceIndex is
input: a number to point on the nth occurrence.
output: the index of the nth occurrence.
Return the nth item of the occurrences field if any.
method clone is
output: a WordOccurrences object containing the same data.
Call clone on the super class.
On the returned object, set the occurrences field with the value of the local occurrences field.
Return the cloned object.
text := "The prototype pattern is a creational design pattern in software development first described in design patterns, the book."
word := "pattern"d
searchEngine := new WordOccurrences
anotherSearchEngine := searchEngine.clone

C# example

This pattern creates the concrete type of object using its prototype. In other words, while creating the object of Prototype object, the class actually creates a clone of it and returns it as prototype. You can see here, we have used MemberwiseClone method to clone the prototype when required.

public abstract class Prototype
public class ConcretePrototype1 : Prototype
public class ConcretePrototype2 : Prototype

C++ example

Discussion of the design pattern along with a complete illustrative example implementation using polymorphic class design are provided in the .

Java example

This pattern creates the kind of object using its prototype. In other words, while creating the object of Prototype object, the class creates a clone of it and returns it as prototype. The clone method has been used to clone the prototype when required.

// Prototype pattern
public abstract class Prototype implements Cloneable
public class ConcretePrototype1 extends Prototype
public class ConcretePrototype2 extends Prototype

PHP example


// The Prototype pattern in PHP is done with the use of built-in PHP function __clone
abstract class Prototype
class ConcretePrototype1 extends Prototype
class ConcretePrototype2 extends Prototype
$cP1 = new ConcretePrototype1;
$cP2 = new ConcretePrototype2;
$cP2C = clone $cP2;
// RESULT: #quanton81
// CONS: A1
// CONS: B1
// CONS: A2
// CONS: B2
// CLON: A2-C
// CLON: B2-C

Python example

Python version 3.8+
from abc import ABC, abstractmethod
from typing import AnyStr
class A:
"""Abstract class"""
@abstractmethod
def whois -> AnyStr:
pass
class Concrete:
"""Concrete class"""
def whois -> AnyStr:
"""Overriding of whois method of the abstract class A"""
return f"Concrete: "
c = Concrete
print)
Output:
Concrete: <__main__.Concrete object at 0x1023bafd0>