Prototype pattern

Overview

The Prototype pattern creates new objects by copying an existing instance (the prototype) instead of constructing from scratch. It is useful when construction is expensive (loading templates, parsing configs) or when you want many similar objects that differ slightly, such as document templates or game units.

The core decision is shallow vs deep copy. A shallow copy shares nested objects with the original, so changing a nested list affects both. A deep copy duplicates the whole graph. A prototype registry stores named prototypes that clients clone and customize.

When to use it

• Object creation is costly but copying is cheap.
• Many objects start from a few preset configurations.
• You need copies without knowing concrete classes.

Where it shows up in interviews

Where it is used in real software

Key terms

Prototype

An instance used as a template for copies.

clone / copy

Method that returns a copy of the object.

Shallow copy

Copies top-level fields; nested objects are shared.

Deep copy

Recursively copies nested objects.

Prototype registry

Named collection of prototypes.

How it works, step by step

1. 1
   Define a copy method

   In an interface: copy(): T.

2. 2
   Implement it per class

   Decide shallow vs deep per field.

3. 3
   Create prototypes

   Preconfigured instances.

4. 4
   Register them

   Map name to prototype.

5. 5
   Clone and customize

   registry.get('invoice').copy().withCustomer(c).

Shallow vs deep copy

original = { title: 'Report', tags: ['q1'] }

Shallow copies are fast but share nested state; choose deliberately per field.

Implementation

1interface Prototype<T> { copy(): T }2 3class DocumentTemplate implements Prototype<DocumentTemplate> {4  constructor(5    public title: string,6    public sections: string[],7    public styles: { font: string; size: number },8  ) {}9 10  copy(): DocumentTemplate {11    return new DocumentTemplate(this.title, [...this.sections], { ...this.styles }); // deep enough12  }13}14 15class TemplateRegistry {16  private templates = new Map<string, DocumentTemplate>();17  register(name: string, t: DocumentTemplate) { this.templates.set(name, t); }18  create(name: string) {19    const t = this.templates.get(name);20    if (!t) throw new Error(`Unknown template ${name}`);21    return t.copy();22  }23}24 25const registry = new TemplateRegistry();26registry.register("invoice", new DocumentTemplate("Invoice", ["Header", "Items", "Total"], { font: "Inter", size: 11 }));27const doc = registry.create("invoice");28doc.sections.push("Notes"); // prototype unaffected

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Using Java's Cloneable and Object.clone().

  Fix: It is shallow and awkward; prefer copy constructors or copy methods.

• Accidentally sharing mutable nested state.

  Fix: Copy collections and mutable children.

Interview questions

Practice problems