Prototype Design Pattern

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
Co-opt one instance of a class for use as a breeder of all future instances.

Prototype design pattern is used when very similar objects frequently are required. Prototype pattern clones objects and set the changed feature. This way less resources are consumed. 

This pattern is used when creation of object is costly or complex.

When creating an object is time consuming and a costly affair and you already have a most similar object instance in hand, then you go for prototype pattern. Instead of going through a time consuming process to create a complex object, just copy the existing similar object and modify it according to your needs.

http://www.journaldev.com/1440/prototype-pattern-in-java

Prototype pattern is used when the Object creation is a costly affair and requires a lot of time and resources and you have a similar object already existing. So this pattern provides a mechanism to copy the original object to a new object and then modify it according to our needs. This pattern uses java cloning to copy the object.

http://www.tutorialspoint.com/design_pattern/prototype_pattern.htm

Prototype pattern refers to creating duplicate object while keeping performance in mind. 

This pattern involves implementing a prototype interface which tells to create a clone of the current object. This pattern is used when creation of object directly is costly. For example, a object is to be created after a costly database operation. We can cache the object, returns its clone on next request

http://howtodoinjava.com/2013/01/04/prototype-design-pattern-in-java/

A prototype is a template of any object before the actual object is constructed. Prototype design pattern is used in scenarios where application needs to create a number of instances of a class, which has almost same state or differs very little.

an instance of actual object (i.e. prototype) is created on starting, and thereafter whenever a new instance is required, this prototype is cloned to have another instance. The main advantage of this pattern is to have minimal instance creation process which is much costly than cloning process.

Design participants

• Prototype : This is the prototype of actual object as discussed above.
• Prototype registry : This is used as registry service to have all prototypes accessible using simple string parameters.
• Client : Client will be responsible for using registry service to access prototype instances.

The Prototype pattern creates a new object by cloning an existing object.

1. Add a clone() method to the existing "product" hierarchy.
2. Design a "registry" that maintains a cache of prototypical objects. The registry could be encapsulated in a new Factory class, or in the base class of the "product" hierarchy.
3. Design a factory method that: may (or may not) accept arguments, finds the correct prototype object, calls clone() on that object, and returns the result.
4. The client replaces all references to the new operator with calls to the factory method.

• Abstract Factory classes are often implemented with Factory Methods, but they can be implemented using Prototype.
• Prototype doesn't require subclassing, but it does require an "initialize" operation. Factory Method requires subclassing, but doesn't require Initialize.
• Prototypes are useful when object initialization is expensive, and you anticipate few variations on the initialization parameters. In this context, Prototype can avoid expensive "creation from scratch", and support cheap cloning of a pre-initialized prototype.

Application
Shape/Subclasses
ShapeCache
Examples

When to use it?

The creation of each object is costly or complex.

A limited number of state combinations exist in an object.

New objects created from the "skeleton" of an existing object inherit references to existing functions on the prototype chain, thus boosting performance and keeping memory footprints to a minimum.

Prototype Design Pattern Used in JDK

java.lang.Object - clone()

Also refer to http://java.dzone.com/articles/intro-design-patterns-prototype
Read full article from Prototype Design Pattern