Prototype

Motivation

The Prototype design pattern makes it simple to recreate configured instances that need to maintain independence from one another.

This is done by storing an initial instance that acts as a mold. When new instances are needed, the mold is cloned and the clone is acted upon, while the original instance remains in its initial state.

This pattern is appropriate when:

• Creation and configuration of an object should be decoupled from how it is used.
• Different configurations may be created at run-time and may be used as a template for new instances.
• There are a reasonable number of configuration combinations.
• It is more efficient to copy a pre-configured instance than it is to construct it from scratch.

Code

public interface Prototype {
    Prototype clone();

    void performOperation();
}

Using Java's Cloneable interface, which uses the clone method from the Object class is discouraged.

This discussion with Josh Bloch describes some of the shortcomings of Java's Cloneable interface.

For this reason, the Prototype interface does not extend Cloneable.

public class ConcretePrototype implements Prototype {
    // Publicly accessible to simplify example.
    public int mValue;

    public ConcretePrototype(int value) {
        this.value = value;
    }

    public ConcretePrototype clone() {
        ConcretePrototype clone = new ConcretePrototype(value);
    }

    public void performOperation() {
        System.out.println("ConcretePrototype containing value: " + value);
    }
}

Any concrete Prototype class needs to supply an implementation for the clone() method. Primitive values are straightforward, since copies are made automatically.

Member varibles that contain mutable object references must be handled with care. When implementing the clone() method, it must be determined whether a shallow copy of the object is sufficient or if a deep copy is necessary.

When implementing a deep copy, circular references also must be accounted for properly.

An init() method also may be added in order to allow for more fine grained configuration. This can help cut down on the number of ConcretePrototype instances that are required.

public class Client {
    Prototype mPrototype;

    public Client(Prototype prototype) {
        mPrototype = prototype;
    }

    public void performOperation() {
        // Make a copy of the prototype and perform any necessary
        // operations with it.
        mPrototype.clone().performOperation();
    }
}

This is a simple approach to utilizing a Prototype. Whenever a new instance is needed, a copy of the Prototype instance stored in the client is made.

Cloning is crucial when multiple copies are needed and it is important for all copies to maintain independence from one another.

The Prototype pattern is effective when constructing a copy from scratch is more expensive than the clone() operation. It also allows the storing of a pre-configured instance that can be used as a mold for future instances.

By pre-configuring an instance, this cuts out the need for nested Factory classes, which often must mirror the subclass hierarchy that they traverse in order to return the correct class type to instantiate.

public class Client {
    Map<Integer, Prototype> mPrototypeMap = new HashMap<>();

    public void putPrototype(int value) {
        mPrototypeMap.put(value, new ConcretePrototype(value));
    }

    public void performOperation(int value) {
        // Retrieve the desired prototype.
        Prototype prototype = mPrototypeMap.get(value)

        // Clone and use the new copy.
        prototype.clone().performOperation();
    }
}

The Client class above registers Prototype instances by storing it in a hash.

When a particular Prototype instance is required, it can be retrieved via its key and cloned. Once a copy is made, the client can perform any work necessary with the clone.

It's also common to create a PrototypeManager class to handle registering and retrieving Prototype instances, if something more complex than a hash is necessary.

// Client usage
Client client = new Client();

// Register prototypes
client.putPrototype(1);
client.putPrototype(2);

client.performOperation(1);
client.performOperation(2);

// Output:
// ConcretePrototype containing value: 1
// ConcretePrototype containing value: 2

References

• Design Patterns - Gang of Four