Prototype Pattern: Cloning Instead of Constructing

// VIOLATION: every GameCharacter is built by re-running expensive setup —
// loading a 3D mesh from disk and computing derived stats — even when
// the caller only wants a copy with a different name.
class GameCharacter {
    private final String name;
    private final Mesh mesh;               // loaded from a file — slow
    private final Map<String, Integer> baseStats; // computed from a stat table — slow
 
    GameCharacter(String name, String meshFile) {
        this.name = name;
        this.mesh = MeshLoader.loadFromDisk(meshFile);       // expensive I/O
        this.baseStats = StatCalculator.computeBaseline();    // expensive computation
    }
}
 
// Spawning 50 orcs means re-loading the mesh and recomputing stats 50 times,
// even though every orc's mesh and base stats are IDENTICAL.
List<GameCharacter> orcs = new ArrayList<>();
for (int i = 0; i < 50; i++) {
    orcs.add(new GameCharacter("Orc-" + i, "orc.mesh")); // 50x redundant disk I/O
}

// VIOLATION: shallow copy — mutable fields are shared by reference,
// not actually duplicated.
class GameCharacter implements Cloneable {
    String name;
    List<String> inventory; // mutable, shared reference after clone()
 
    @Override
    public GameCharacter clone() {
        try {
            return (GameCharacter) super.clone(); // Object.clone() = SHALLOW copy
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }
}
 
GameCharacter orcTemplate = new GameCharacter();
orcTemplate.inventory = new ArrayList<>(List.of("axe"));
 
GameCharacter orc1 = orcTemplate.clone();
orc1.inventory.add("shield"); // mutates the SAME list orcTemplate.inventory references!
 
System.out.println(orcTemplate.inventory); // ["axe", "shield"] — template corrupted!

// FIXED: deep copy — mutable fields are independently duplicated
class GameCharacter implements Cloneable {
    String name;
    List<String> inventory;
 
    @Override
    public GameCharacter clone() {
        try {
            GameCharacter copy = (GameCharacter) super.clone(); // shallow copy first...
            copy.inventory = new ArrayList<>(this.inventory);   // ...then deep-copy mutable fields
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }
}
 
GameCharacter orc1 = orcTemplate.clone();
orc1.inventory.add("shield"); // only orc1's OWN list is mutated now
 
System.out.println(orcTemplate.inventory); // ["axe"] — template is safe

class Broken {
    // Cloneable is a MARKER interface — it declares NO methods at all.
    // It doesn't require or even declare clone(); it only changes what
    // Object.clone() does at runtime (throws if the marker is absent).
}
 
Broken b = new Broken();
b.clone(); // COMPILE ERROR — clone() is protected on Object and Broken didn't override it

// PREFERRED: an ordinary constructor that takes another instance of the
// same type and copies its state — no Cloneable, no checked exception,
// full control and visibility of what gets deep-copied.
class GameCharacter {
    private final String name;
    private final Mesh mesh;              // assume Mesh is immutable/shareable
    private final List<String> inventory; // mutable — must be deep-copied
 
    GameCharacter(String name, Mesh mesh, List<String> inventory) {
        this.name = name;
        this.mesh = mesh;
        this.inventory = new ArrayList<>(inventory);
    }
 
    // Copy constructor — explicit, type-safe, no exceptions to catch
    GameCharacter(GameCharacter source) {
        this.name = source.name;
        this.mesh = source.mesh;                          // safe to share — immutable
        this.inventory = new ArrayList<>(source.inventory); // deep copy — mutable
    }
 
    GameCharacter withName(String newName) {
        GameCharacter copy = new GameCharacter(this);
        return new GameCharacter(newName, copy.mesh, copy.inventory);
    }
}
 
// Usage — no checked exception, no cast, no marker interface
GameCharacter orcTemplate = new GameCharacter("Orc Template", orcMesh, List.of("axe"));
GameCharacter orc1 = new GameCharacter(orcTemplate);

class CharacterPrototypeRegistry {
    private final Map<String, GameCharacter> prototypes = new HashMap<>();
 
    void register(String key, GameCharacter prototype) {
        prototypes.put(key, prototype);
    }
 
    GameCharacter create(String key) {
        GameCharacter prototype = prototypes.get(key);
        if (prototype == null) {
            throw new IllegalArgumentException("No prototype registered for: " + key);
        }
        return new GameCharacter(prototype); // clone via copy constructor
    }
}
 
// Setup once, at startup — pays the expensive construction cost exactly once per template:
CharacterPrototypeRegistry registry = new CharacterPrototypeRegistry();
registry.register("orc", new GameCharacter("Orc Template", MeshLoader.loadFromDisk("orc.mesh"), List.of("axe")));
registry.register("elf", new GameCharacter("Elf Template", MeshLoader.loadFromDisk("elf.mesh"), List.of("bow")));
 
// Spawning is now cheap — clone + rename, no disk I/O per spawn:
GameCharacter orc7 = registry.create("orc");

// Works for any Serializable graph — the round trip forces every reachable
// mutable object to be freshly reconstructed, guaranteeing no shared references.
static <T extends Serializable> T deepCopyViaSerialization(T original) {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos)) {
        oos.writeObject(original);
        try (ObjectInputStream ois =
                 new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()))) {
            @SuppressWarnings("unchecked")
            T copy = (T) ois.readObject();
            return copy;
        }
    } catch (IOException | ClassNotFoundException e) {
        throw new RuntimeException("Deep copy failed", e);
    }
}