Creational Patterns  «Prev  Next»

Prototype Pattern

The Prototype pattern allows an object to create customized objects without knowing their exact class or the details of how to create them.It specifies the kinds of objects to create using a prototypical instance, and creates new objects by copying this prototype. The Prototype pattern works by giving prototypical objects to an object and then initiates the creation of objects. The creation-initiating object then creates objects by asking the prototypical objects to make copies of themselves. The Prototype pattern makes creating objects dynamically easier by defining classes whose objects can duplicate themselves.

Prototype Pattern consisting of PrototypeClient and abstract Prototype class.
Prototype Pattern Java Code


The following lists the benefits of using the Prototype pattern:
  1. Adding and removing products at run time.
  2. Specifying new objects by varying values.
  3. Specifying new objects by varying structure
  4. Reduced subclassing
  5. Configuring an application with classes dynamically

When To Use the Prototype Pattern:

  1. The classes to instantiate are specified at run time, for example, by dynamic loading.
  2. To avoid building a class hierarchy of factories that parallels the class hierarchy of products
  3. When instances of a class can have one of only a few different combinations of state
The prototype pattern is a creational design pattern used in software development 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:
  1. avoid subclasses of an object creator in the client application, like the abstract factory pattern does.
  2. avoid the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) when it is prohibitively expensive for a given application.

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.