Andre has posted 4 posts at DZone. View Full User Profile

Intro to Design Patterns: Prototype Pattern

  • submit to reddit

Today we're going to look at the Prototype design pattern.  Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype. - Gof


Object Creational


The Prototype pattern creates a new object by cloning an existing object. The client using the prototype object does not need to know what kind of object it is dealing with as long as the concrete prototype extends or implements the prototype interface/class. The concrete prototype object is responsible for cloning itself and returning the cloned object.

The pattern enables a client to create the kind of object required at runtime by selecting the appropriate prototype. The prototype classes are created generically by the client without the client knowing the exact type of the concrete prototype. New concrete prototypes can be added at runtime as long as they conform to the abstract prototype.


Design Pattern, Prototype Pattern, GOF

Java Sample Code

Example 1:

Download Example 1

The following is an example of the Prototype Pattern. The prototype object is an Animal object. The Animal prototype contains two concrete prototype subclasses called Sheep and Chicken. The AnimalCreator class contains references to the two concrete prototypes. During the initialization of the AnimalCreator class the two concrete prototypes, Sheep and Chicken are created and stored as the two concrete prototypes members of the AnimalCreator class. The AnimalCreator class contains a retrieveAnimal method that clones a prototype Animal depending on the parameter that is passed to it.
The Animal class is the abstract prototype of the two concrete prototypes in the example. The client invokes methods on the two different concrete prototypes through the Animal type to ensure the client does not know the type of the concrete prototypes.

Most importantly, the Animal prototype defines a clone method to assist the two subtypes or concrete prototypes to clone themselves.


public Animal clone() {	 

Animal clonedAnimal = null;
try {
clonedAnimal = (Animal) super.clone();
} catch (CloneNotSupportedException e) {
} // catch
return clonedAnimal;
} // method clone
The Sheep object is a concrete prototype that extends the Animal prototype. The Sheep prototype has a clone method to clone itself to create a new object.


public class Sheep extends Animal {
The Chicken object is a concrete prototype that extends the Animal prototype. The Chicken prototype has a clone method to clone itself to create a new object.


public class Chicken extends Animal {
The AnimalCreator class is used to create and manage prototype objects. The AnimalCreator class contains two concrete prototypes that are initialized during the initialization of the class. The AnimalCreator class forms part of the "Prototype" pattern by returning a cloned object (Animal) to the client without the client knowing the type of the prototype.


public Animal retrieveAnimal(String kindOfAnimal) {	
if ("Chicken".equals(kindOfAnimal)) {
return (Animal) chicken.clone();
} else if ("Sheep".equals(kindOfAnimal)) {
return (Animal) sheep.clone();
} // if

return null;
} // method retrieveAnimal
The AnimalClient class makes use of the AnimalCreator class to create a concrete prototypes of type Animal. The AnimalClient class does not know the type of the concrete prototypes but references them through the Animal prototype.


AnimalCreator animalCreator = new AnimalCreator();	 
Animal[] animalFarm = new Animal[8];
animalFarm[0] = animalCreator.retrieveAnimal("Chicken");
animalFarm[1] = animalCreator.retrieveAnimal("Chicken");
animalFarm[2] = animalCreator.retrieveAnimal("Chicken");
animalFarm[3] = animalCreator.retrieveAnimal("Chicken");
animalFarm[4] = animalCreator.retrieveAnimal("Sheep");
animalFarm[5] = animalCreator.retrieveAnimal("Sheep");
animalFarm[6] = animalCreator.retrieveAnimal("Sheep");
animalFarm[7] = animalCreator.retrieveAnimal("Sheep");
for (int i= 0; i<=7; i++) {
} // for

The following is the output of the AnimalClient calling different concrete prototype objects.

Cluck cluck World. I am Chicken1. I have 2 legs.
Cluck cluck World. I am Chicken2. I have 2 legs.
Cluck cluck World. I am Chicken3. I have 2 legs.
Cluck cluck World. I am Chicken4. I have 2 legs.
Meeeeeee World. I am Sheep1. I have 4 legs.
Meeeeeee World. I am Sheep2. I have 4 legs.
Meeeeeee World. I am Sheep3. I have 4 legs.
Meeeeeee World. I am Sheep4. I have 4 legs.

Class Diagram Example

Design Pattern, Prototype Pattern, GOF

Sequence Diagram

Sequence Diagram by "Yanic Inghelbrecht" with Trace Modeler


  • Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley, 1995
Published at DZone with permission of its author, Andre Mare.

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)


Surya De replied on Wed, 2008/05/07 - 2:38pm

Nice read thanks. I really like and appreciate these kinds of articles. Perfect for reading and browsing and refreshing one's memory when in a incredibly boring demo meeting. :)

David Voo replied on Wed, 2008/05/07 - 9:26pm

Very good explanation. The key point is this:

clonedAnimal = (Animal) super.clone(); 

which can be mimic using constructor-like objects creation like:


Object objA = new Object("chicken");

Object objB = new Object("sheep");


but of course it serve a different purpose though. Nice one!

Nikkithan Shaveen replied on Wed, 2008/05/07 - 11:33pm

Good article.

 It could be more helpful if it can address waht is the limitation of this pattern. Say for an example, can we use the prototype pattern all the times for creating objects instead of using the new constructor().

Eagerly looking for reply exclusively for this.  


Collin Fagan replied on Fri, 2008/05/09 - 6:15am

This is an interesting pattern. I am unsure though in what circumstances this pattern should be applied. Clone is almost always more complicated to implement then a constructor. The only time I've even applied this was when a 3rd party object did file I/O in it's constructor. I had to create a dozens of these objects so I went the cloning route to avoid all the file I/O. Anyone have any other good circumstances for this pattern?

nilesh gule replied on Wed, 2012/06/20 - 9:32am

Nice post. I recently posted about Prototype design pattern in C#. Although your post is related to Java, I think it might be helpful for others to find the similarities in implementation of the pattern in C#.

<a href="">here</a> is a link to my post 

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.