Prototype Pattern · Design Patterns

What is the Prototype pattern?

Prototype means: make a new object by copying an existing one, instead of building it from scratch.

You keep one ready-made object around. When you need another like it, you clone it instead of repeating the setup work.

To build it you usually:

Give the object a clone (or copy) method.
Keep one configured instance around as the template.
Copy mutable fields too, not just references, when it matters.

The problem it solves

Without cloning, every new object pays the full cost of construction, even when the result is nearly identical.

doc1 = WordDocument("Template", "DOCX")  # expensive setup, every time
doc2 = WordDocument("Template", "DOCX")  # same setup, repeated

WordDocument doc1 = new WordDocument("Template", "DOCX"); // expensive setup, every time
WordDocument doc2 = new WordDocument("Template", "DOCX"); // same setup, repeated

doc1 := NewWordDocument("Template", "DOCX") // expensive setup, every time
doc2 := NewWordDocument("Template", "DOCX") // same setup, repeated

const doc1 = new WordDocument('Template', 'DOCX'); // expensive setup, every time
const doc2 = new WordDocument('Template', 'DOCX'); // same setup, repeated

If building it reads a file, calls a service, or runs real validation, doing that twice — or a hundred times — is wasted work.

You want to say: build the expensive part once, then get cheap copies after that.

Basic cloning

Give the object a clone() method, keep one template around, and hand out copies instead of rebuilding.

import copy

class WordDocument:
    def __init__(self, content: str, format: str) -> None:
        self.content = content
        self.format = format
        print("Creating WordDocument (expensive)")

    def clone(self) -> "WordDocument":
        return copy.copy(self)

# use
template = WordDocument("Template", "DOCX")

doc1 = template.clone()
doc1.content = "Document 1"

doc2 = template.clone()
doc2.content = "Document 2"
# "Creating WordDocument" prints only once

public interface Document extends Cloneable {
    Document clone();
    void setContent(String content);
}

public class WordDocument implements Document {
    private String content;
    private String format;

    public WordDocument(String content, String format) {
        this.content = content;
        this.format = format;
        System.out.println("Creating WordDocument (expensive)");
    }

    @Override
    public Document clone() {
        try {
            return (Document) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void setContent(String content) {
        this.content = content;
    }
}

// use
WordDocument template = new WordDocument("Template", "DOCX");

Document doc1 = template.clone();
doc1.setContent("Document 1");

Document doc2 = template.clone();
doc2.setContent("Document 2");
// "Creating WordDocument" prints only once

package document

import "fmt"

type WordDocument struct {
	Content string
	Format  string
}

func NewWordDocument(content, format string) *WordDocument {
	fmt.Println("Creating WordDocument (expensive)")
	return &WordDocument{Content: content, Format: format}
}

func (d *WordDocument) Clone() *WordDocument {
	copy := *d // shallow copy — fields are copied by value
	return &copy
}

// use
// template := document.NewWordDocument("Template", "DOCX")
// doc1 := template.Clone()
// doc1.Content = "Document 1"
// doc2 := template.Clone()
// doc2.Content = "Document 2"
// "Creating WordDocument" prints only once

class WordDocument {
  content: string;
  format: string;

  constructor(content: string, format: string) {
    this.content = content;
    this.format = format;
    console.log('Creating WordDocument (expensive)');
  }

  clone(): WordDocument {
    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
  }
}

// use
const template = new WordDocument('Template', 'DOCX');

const doc1 = template.clone();
doc1.content = 'Document 1';

const doc2 = template.clone();
doc2.content = 'Document 2';
// "Creating WordDocument" prints only once

The expensive setup message prints exactly once — when the template is built. Every clone after that is cheap.

Java’s Cloneable/clone() has a well-known reputation for being awkward — the checked exception, the cast. Many teams skip it entirely and write a plain copy method instead, which is exactly what the Python, Go, and TypeScript examples above already do.

Shallow vs deep copy

This is where most cloning bugs happen, so slow down here. A plain copy duplicates each field’s value. For simple fields (numbers, strings) that is fine. But for a field that points at something mutable, like a list, a shallow copy copies the reference — both objects end up pointing at the same list.

import copy

class ShallowExample:
    def __init__(self, items: list[str]) -> None:
        self.items = items

# use
original = ShallowExample(["a"])
clone = copy.copy(original)
clone.items[0] = "changed"
# original.items is also "changed" — same list!

public class ShallowExample implements Cloneable {
    private List<String> items;

    public ShallowExample(List<String> items) {
        this.items = items;
    }

    @Override
    public ShallowExample clone() {
        try {
            return (ShallowExample) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    public List<String> getItems() { return items; }
}

// use
ShallowExample original = new ShallowExample(new ArrayList<>(List.of("a")));
ShallowExample copy = original.clone();
copy.getItems().set(0, "changed");
// original.getItems() is also "changed" — same list!

type ShallowExample struct {
	Items []string
}

func (s ShallowExample) Clone() ShallowExample {
	return s // shallow copy — slice header is copied, backing array is shared
}

// use
original := ShallowExample{Items: []string{"a"}}
clone := original.Clone()
clone.Items[0] = "changed"
// original.Items[0] is also "changed" — same backing array!

class ShallowExample {
  constructor(public items: string[]) {}

  clone(): ShallowExample {
    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
  }
}

// use
const original = new ShallowExample(['a']);
const clone = original.clone();
clone.items[0] = 'changed';
// original.items is also 'changed' — same array!

A deep copy fixes this by also copying the mutable field itself, not just the reference to it.

import copy

class DeepExample:
    def __init__(self, items: list[str]) -> None:
        self.items = list(items)

    def clone(self) -> "DeepExample":
        return copy.deepcopy(self)

# use
original = DeepExample(["a"])
clone = original.clone()
clone.items[0] = "changed"
# original.items is unchanged — separate lists now

public class DeepExample implements Cloneable {
    private List<String> items;

    public DeepExample(List<String> items) {
        this.items = new ArrayList<>(items);
    }

    @Override
    public DeepExample clone() {
        try {
            DeepExample copy = (DeepExample) super.clone();
            copy.items = new ArrayList<>(this.items); // new list, same contents
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    public List<String> getItems() { return items; }
}

// use
DeepExample original = new DeepExample(new ArrayList<>(List.of("a")));
DeepExample copy = original.clone();
copy.getItems().set(0, "changed");
// original.getItems() is unchanged — separate lists now

type DeepExample struct {
	Items []string
}

func (d DeepExample) Clone() DeepExample {
	items := make([]string, len(d.Items))
	copy(items, d.Items) // new backing array
	return DeepExample{Items: items}
}

// use
original := DeepExample{Items: []string{"a"}}
clone := original.Clone()
clone.Items[0] = "changed"
// original.Items[0] is unchanged — separate backing arrays now

class DeepExample {
  items: string[];

  constructor(items: string[]) {
    this.items = [...items];
  }

  clone(): DeepExample {
    return new DeepExample(this.items);
  }
}

// use
const original = new DeepExample(['a']);
const clone = original.clone();
clone.items[0] = 'changed';
// original.items is unchanged — separate arrays now

Rule of thumb: simple fields are fine to copy as-is; mutable fields — lists, maps, other cloneable objects — need to be copied themselves inside the clone.

Worked example: cloning a catalog listing

A more realistic case: a product listing with a mutable list of tags, used as a template for new listings.

class ProductListing:
    def __init__(self, name: str, price: float, tags: list[str]) -> None:
        self.name = name
        self.price = price
        self.tags = list(tags)

    def clone(self) -> "ProductListing":
        return ProductListing(self.name, self.price, self.tags)

    def add_tag(self, tag: str) -> None:
        self.tags.append(tag)

    def describe(self) -> str:
        return f"{self.name} (${self.price}) tags={self.tags}"

# use
template = ProductListing("Mug", 9.99, ["kitchen", "gift"])

custom = template.clone()
custom.name = "Personalized Mug"
custom.add_tag("custom")

print(template.describe())
# Mug ($9.99) tags=['kitchen', 'gift']
print(custom.describe())
# Personalized Mug ($9.99) tags=['kitchen', 'gift', 'custom']

public class ProductListing implements Cloneable {
    private String name;
    private final double price;
    private List<String> tags;

    public ProductListing(String name, double price, List<String> tags) {
        this.name = name;
        this.price = price;
        this.tags = new ArrayList<>(tags);
    }

    @Override
    public ProductListing clone() {
        try {
            ProductListing copy = (ProductListing) super.clone();
            copy.tags = new ArrayList<>(this.tags);
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    public void setName(String name) { this.name = name; }
    public void addTag(String tag) { tags.add(tag); }

    public String describe() {
        return name + " ($" + price + ") tags=" + tags;
    }
}

// use
ProductListing template = new ProductListing("Mug", 9.99, List.of("kitchen", "gift"));

ProductListing custom = template.clone();
custom.setName("Personalized Mug");
custom.addTag("custom");

System.out.println(template.describe());
// Mug ($9.99) tags=[kitchen, gift]
System.out.println(custom.describe());
// Personalized Mug ($9.99) tags=[kitchen, gift, custom]

package catalog

import "fmt"

type ProductListing struct {
	Name  string
	Price float64
	Tags  []string
}

func NewProductListing(name string, price float64, tags []string) *ProductListing {
	t := make([]string, len(tags))
	copy(t, tags)
	return &ProductListing{Name: name, Price: price, Tags: t}
}

func (p *ProductListing) Clone() *ProductListing {
	return NewProductListing(p.Name, p.Price, p.Tags)
}

func (p *ProductListing) AddTag(tag string) {
	p.Tags = append(p.Tags, tag)
}

func (p *ProductListing) Describe() string {
	return fmt.Sprintf("%s ($%.2f) tags=%v", p.Name, p.Price, p.Tags)
}

// use
// template := catalog.NewProductListing("Mug", 9.99, []string{"kitchen", "gift"})
// custom := template.Clone()
// custom.Name = "Personalized Mug"
// custom.AddTag("custom")
// fmt.Println(template.Describe())  // Mug ($9.99) tags=[kitchen gift]
// fmt.Println(custom.Describe())    // Personalized Mug ($9.99) tags=[kitchen gift custom]

class ProductListing {
  name: string;
  readonly price: number;
  tags: string[];

  constructor(name: string, price: number, tags: string[]) {
    this.name = name;
    this.price = price;
    this.tags = [...tags];
  }

  clone(): ProductListing {
    return new ProductListing(this.name, this.price, this.tags);
  }

  addTag(tag: string) {
    this.tags.push(tag);
  }

  describe() {
    return `${this.name} ($${this.price}) tags=${this.tags}`;
  }
}

// use
const template = new ProductListing('Mug', 9.99, ['kitchen', 'gift']);

const custom = template.clone();
custom.name = 'Personalized Mug';
custom.addTag('custom');

console.log(template.describe());
// Mug ($9.99) tags=kitchen,gift
console.log(custom.describe());
// Personalized Mug ($9.99) tags=kitchen,gift,custom

Because clone() deep-copies tags, adding "custom" to the copy leaves the template untouched. A shallow copy here would have silently polluted the template too.

When it helps

Prototype earns its place when building an object from scratch is genuinely expensive — it hits disk, calls a service, or runs heavy validation — and you need several objects that start from the same state.

The test: would building this a second time do real, avoidable work that a copy would skip?

When it hurts

If constructing an object is already cheap, cloning adds complexity for no real savings. A shallow-copy bug can also sit undetected until two “independent” objects start mysteriously affecting each other.

Objects that reference each other in a cycle (A holds B, B holds A) make deep cloning tricky too — a naive deep copy can recurse forever.

Practical tips

Prefer a plain copy method or copy constructor over Cloneable/clone() for new code.
For every mutable field, ask: does this need its own copy inside clone()?
Say clearly whether a copy is shallow or deep — the next reader should not have to guess.
Reach for Prototype when construction cost, not construction complexity, is the problem. Expensive → Prototype. Complex but cheap → Builder.

Check your understanding

Prototype in one line?
Make a new object by copying an existing, ready-made one.

Shallow copy vs deep copy?
Shallow copy shares mutable fields with the original. Deep copy duplicates them too, so the two objects are fully independent.

Why do many languages skip built-in clone machinery?
It is easy to forget to deep-copy a mutable field. A plain copy method is clearer and just as effective.

When is Prototype worth using?
When building from scratch does real, repeatable work, and you need several similar objects.

What is the main risk?
Forgetting to deep-copy a mutable field, so the “independent” copy secretly shares state with the original.

What to learn next

Next: Adapter Pattern — the problem shifts from “how do I create objects” to “how do I make two incompatible interfaces work together.”