Prototype pattern
|
|
de:Prototyp (Entwurfsmuster) A software design pattern prototype pattern is used for computer programming.
| Contents |
Intent
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
Problem
Application "hard wires" the class of object to create in each "new" expression and the creation of a factory object is inherently expensive.
Discussion
Declare an abstract base class that specifies a pure virtual "clone" method and maintains a dictionary of all "cloneable" concrete derived classes. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, registers its prototypical instance, and implements the clone() operation.
The client then, instead of writing code that invokes the "new" operator on a hard-wired class name, calls a "clone" operation on the abstract base class, supplying a string or enumerated data type that designates the particular concrete derived class desired.
Structure
This diagram is from javacoder.net (http://www.javacoder.net/patterns.jsp).
Missing image
PrototypeJavacoder.png
Image:PrototypeJavacoder.png
Java sample code
Above an example of Prototype pattern with assistance of Factory pattern
/**
* Record is the Prototype
*/
public abstract class Record implements Cloneable {
public abstract Object clone();
}
/**
* PersonRecord is the Concrete Prototype
*/
public class PersonRecord extends Record {
String name;
int age;
...
public Object clone() {
return new PersonRecord();
}
}
/**
* CarRecord is another Concrete Prototype
*/
public class CarRecord extends Record {
String carname;
Color color;
...
public Object clone() {
return new CarRecord();
}
}
/**
* RecordFactory is the client
*/
public class RecordFactory {
Record recordmodel = null;
...
// Constructor
public RecordFactory(Record recordmodel) {
this.recordmodel = recordmodel;
}
...
// the Factory Method
public Record createRecord() {
return recordmodel.clone();
}
...
// TODO: is the a tecnical name for this method?
public void changeRecordtype(Record newmodel) {
this.recordmodel = newmodel;
}
}
With this schema, you can create a RecordFactory object passing an instance of one concrete Record, then, that instance will be the model, or Prototype, which all other Records will be manufactured by RecordFactory.
Example
The Prototype pattern specifies the kind of objects to create using a prototypical instance. Prototypes of new products are often built prior to full production, but in this example, the prototype is passive and does not participate in copying itself. 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. [Michael Duell, "Non-software examples of software design patterns", Object Magazine, Jul 97, p54]
Non-software example (http://www.agcs.com/supportv2/techpapers/patterns/papers/tutnotes/sld006.htm)
Rules of thumb
Sometimes creational patterns are competitors: there are cases when either Prototype or Abstract Factory could be used properly. At other times they are complementory: Abstract Factory might store a set of Prototypes from which to clone and return product objects [GOF, p126]. Abstract Factory, Builder, and Prototype can use Singleton in their implementations. [GOF, p81, 134]. Abstract Factory classes are often implemented with Factory Methods, but they can be implemented using Prototype. [GOF, p95]
Factory Method: creation through inheritance.
Protoype: creation through delegation.
Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward Abstract Factory, Protoype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed. [GOF, p136]
Prototype doesn't require subclassing, but it does require an "initialize" operation. Factory Method requires subclassing, but doesn't require Initialize. [GOF, p116]
Designs that make heavy use of the Composite and Decorator patterns often can benefit from Prototype as well. [GOF, p126]