This lesson follows Builder. Builder assembles from steps. Prototype starts with an object that already exists.

Prototype creates new objects by copying existing ones through a common cloning contract. The object handles its own private state and concrete type. The cost is defining exactly what a copy owns.

Copy through the object that knows the details

A page editor duplicates a selected card. The selected object might be a text card, a chart card, or a plugin card. Code outside the card does not know every constructor or private field. A switch on card type grows with every plugin.

interface Card {
  clone(): Card;
  render(): string;
}

type Style = { color: string };
class TextCard implements Card {
  constructor(private title: string, private style: Style) {}
  clone(): TextCard {
    return new TextCard(this.title, { ...this.style });
  }
  setColor(color: string) { this.style.color = color; }
  render(): string { return this.title + ": " + this.style.color; }
}

function duplicate(selected: Card): Card {
  return selected.clone();
}

const original = new TextCard("Welcome", { color: "blue" });
const copy = original.clone();
copy.setColor("red");
original.render(); // Welcome: blue
copy.render();     // Welcome: red

TextCard can read its own private fields. It constructs another TextCard. A subclass with extra state must implement cloning that preserves that state and its concrete type.

Name what the clone shares

A shallow copy creates a new outer object but reuses references to nested objects. A deep copy also copies selected nested state. Neither is automatically correct. Share immutable configuration. Copy mutable state that the new object should own.

Reuse configured prototypes

A prototype registry maps a name to a configured object. A client asks for the “warning card” and receives a clone. Store the prototype privately. Returning the prototype itself lets callers corrupt the defaults for the next caller.

class CardRegistry {
  private prototypes = new Map<string, Card>();
  register(name: string, card: Card) {
    this.prototypes.set(name, card.clone());
  }
  create(name: string): Card {
    const prototype = this.prototypes.get(name);
    if (!prototype) throw new Error("Unknown card: " + name);
    return prototype.clone();
  }
}

Map the roles

Role	In this example	Job
Prototype	Card	Declares clone(), usually its only creation method
Concrete prototype	TextCard	Implements clone(). Copies its own fields, including private ones, and handles nested state, cycles, and resources.
Client	duplicate(selected)	Copies any object that implements the prototype interface, without naming its class
Prototype registry	CardRegistry	Stores configured prototypes by name and hands out clones

Reach for it when you must copy objects you cannot name

• your code must copy objects without depending on their concrete classes. This happens when objects arrive from third-party code through an interface. You cannot depend on classes you do not know.
• subclasses differ only in how their objects are initialized. Instead of WarningCard, TipCard, and ErrorCard subclasses that only set colors and icons, keep one configured prototype of each and clone it.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Create the prototype interface and declare clone(). In an existing hierarchy, add the method to every class.
2. Give each prototype class a way to copy an object of its own class, such as a copy constructor. It copies every field and calls the parent's copy logic so the parent's private fields are copied too.
3. Implement clone() in every class, usually as one line that calls that copy logic with its own class. Override it in each subclass, or clones come back as the parent type.
4. Optionally, build a central prototype registry that stores frequently used prototypes. Make it a factory class or a static method on the base prototype class, and let it search by name or by richer criteria.
5. Replace direct calls to subclass constructors with calls to the registry, which returns a clone.

Name what it costs

You gain	You pay
Clone objects without coupling to their concrete classes	Each class must implement a correct clone
Skip repeated initialization by cloning pre-built prototypes	Objects with circular references are tricky to clone
Produce complex objects more conveniently	Nested ownership and live resources need a copy policy
Handle configuration presets without a subclass per preset	Copying can still be expensive. Measure the actual work.

Do not confuse it with its neighbors

Pattern	How it relates
Factory Method	Factory Method relies on inheritance and needs no initialization step after creation. Prototype avoids inheritance, but a clone can need complicated initialization.
Abstract Factory	Its creation methods are often factory methods, but they can also clone stored prototypes.
Command	Prototype helps save copies of commands into a history.
Composite and Decorator	Designs that use these heavily benefit from Prototype. Cloning a finished structure is easier than rebuilding it from scratch.
Memento	Prototype can be a simpler memento when the state is simple and holds no links to external resources, or links that are easy to re-establish.
Singleton	A prototype registry, like an abstract factory or a builder, can be implemented as a singleton.

Retrieve and apply

Choose one object from a small application. Mark each field as copy, share, regenerate, or omit. Continue to Singleton for the opposite creation constraint: callers deliberately receive the same object.