Prototype Design Pattern Tutorial

Main ideas / concepts covered

• Prototype (final creational) design pattern: create new objects/instances by cloning or copying existing objects instead of instantiating classes directly.
• What it enables
  • At runtime, add/use a new subclass instance of a known superclass by cloning an existing “prototype” object.
• When to use
  • When there are many potential classes, but you want to create/use only some of them as needed at runtime.
• Key benefit
  • Reduces the need for creating many subclasses just to support different instantiation variations.

Diagram / architecture explained (conceptual flow)

• Client creates:
  • A Clone Factory instance
  • An initial prototype object (example: a Sheep instance)
• The Client asks the Clone Factory to copy/clone the prototype object.
• The prototype object implements a make copy method so cloning is performed correctly via polymorphism:
  • Passes the prototype as the supertype (Animal)
  • The factory calls make copy(), which invokes the correct subclass cloning logic (e.g., Sheep.make copy()).
• Example shown:
  • Sheep and (conceptually) Dog are subclasses of Animal
  • The factory can clone the appropriate subclass even though the client treats them generically as Animal.

Methodology / “how it works” in code (detailed steps)

1) Define the prototype interface/supertype (Animal.java)

• Create an interface named Animal.
• Make the interface extend clonable (intended to represent Java’s Cloneable).
• Declare a single required method:
  • Animal make copy()
• Purpose:
  • Guarantees all implementers can be cloned.
  • Marks instances as safe to copy (Java throws errors if Cloneable isn’t supported).

2) Implement a concrete prototype (Sheep.java)

• Create a class sheep that implements animal.
• Add an optional constructor for logging/testing (e.g., prints when a sheep object is created).
• Implement make copy() to actually clone:
  • Indicate cloning setup (the video mentions a try/catch requirement for clone()).
  • In make copy():
    • Create sheep object = null;
    • Perform cloning using the superclass cloning capability (conceptually super.clone()).
    • Cast the clone result back to the concrete type (sheep).
  • Return the cloned sheep instance.
• Implement toString():
  • So the original and clone can be visually compared.

3) Create a cloning factory / routing layer (Clone Factory)

• Create a class clone Factory with method:
  • Animal get clone(Animal animal sample)
• Behavior:
  • Accept any object that is an Animal subtype.
  • The factory does not need to know the concrete subclass type.
  • It returns:
    • animal sample.make copy()
• Polymorphism effect:
  • Because make copy() is implemented by each subclass, the correct cloning code runs.

4) Test in an application (test cloning.java)

• In main:
  • Instantiate the Clone Factory:
    • animal maker = new Factory (name may be slightly inconsistent in subtitles)
  • Create a prototype object:
    • Sally = new sheep(...)
  • Request a clone:
    • clone sheep = (Sheep) animal maker.get clone(Sally)
  • Compare:
    • Print both objects using toString() to show they look identical.
    • Compare memory identity using hash codes:
      • Sally.hashCode()
      • System.identityHashCode(Sally)
      • System.identityHashCode(copy)
• Result:
  • Same toString() output (same “data”/behavior)
  • Different identity hash codes (different memory locations)

Lessons / takeaway

• The Prototype pattern relies on:
  • A cloning capability in the superclass/interface
  • Subclass-specific cloning logic
  • A factory that routes clone requests without hardcoding subclass types
• Clones should be distinct objects in memory even if they print the same content.

Speakers / sources featured

• Speaker: The unnamed creator/host of the YouTube video (“welcome to part nine…”), presenting and coding the Prototype pattern tutorial.
• Source: YouTube video titled “Prototype Design Pattern Tutorial” (subtitles provided are auto-generated).