Prototype pattern

A sample UML class and sequence diagram for the Prototype design pattern.

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 (a product:Product1 object).

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(text, word) 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(n) 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(text, word)
anotherSearchEngine := searchEngine.clone()

(the search algorithm is not optimized; it is a basic algorithm to illustrate the pattern implementation)

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
{
    // normal implementation

    public abstract Prototype Clone();
}

public class ConcretePrototype1 : Prototype
{
    public override Prototype Clone()
    {
        return (Prototype)this.MemberwiseClone(); // Clones the concrete class.
    }
}

public class ConcretePrototype2 : Prototype
{
    public override Prototype Clone()
    {
        return (Prototype)this.MemberwiseClone(); // Clones the concrete class.
    }
}

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

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 Prototype clone() throws CloneNotSupportedException{
        return (Prototype) super.clone();
    }
}
	
public class ConcretePrototype1 extends Prototype {
    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (ConcretePrototype1)super.clone();
    }
}

public class ConcretePrototype2 extends Prototype {
    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (ConcretePrototype2)super.clone();
    }
}

Python version 3.8+

from abc import ABC, abstractmethod
from typing import AnyStr


class A(ABC):
    """Abstract class"""

    @abstractmethod
    def whois(self) -> AnyStr:
        pass


class Concrete(A):
    """Concrete class"""
    def whois(self) -> AnyStr:
        """Overriding of whois() method of the abstract class A"""
        return f"Concrete: {self}"


c = Concrete()
print(c.whois())

Output:

Concrete: <__main__.Concrete object at 0x1023bafd0>