🧬 Prototype Design Pattern

// Prototype Interface
public interface Prototype<T> {
    T clone();
}

// ========== Shallow Copy Example ==========
public class Address {
    private String street;
    private String city;
    private String country;

    public Address(String street, String city, String country) {
        this.street = street;
        this.city = city;
        this.country = country;
    }

    // Getters and setters
    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    public String getCountry() { return country; }
}

public class Employee implements Prototype<Employee> {
    private String name;
    private String department;
    private Address address;        // Reference type!
    private List<String> skills;    // Reference type!

    public Employee(String name, String department, Address address, 
                    List<String> skills) {
        this.name = name;
        this.department = department;
        this.address = address;
        this.skills = skills;
    }

    // SHALLOW COPY — address and skills are shared references!
    public Employee shallowClone() {
        return new Employee(name, department, address, skills);
    }

    // DEEP COPY — all nested objects are independently copied
    @Override
    public Employee clone() {
        Address clonedAddress = new Address(
            address.getStreet(), address.getCity(), address.getCountry()
        );
        List<String> clonedSkills = new ArrayList<>(skills);
        return new Employee(name, department, clonedAddress, clonedSkills);
    }

    // Getters and setters
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
    public Address getAddress() { return address; }
    public List<String> getSkills() { return skills; }
}

// ========== Usage ==========
public class Demo {
    public static void main(String[] args) {
        Employee original = new Employee(
            "Alice", "Engineering",
            new Address("123 Main St", "San Jose", "USA"),
            new ArrayList<>(List.of("Java", "Spring", "AWS"))
        );

        // Deep clone — independent copy
        Employee clone = original.clone();
        clone.setName("Bob");
        clone.getAddress().setStreet("456 Oak Ave");
        clone.getSkills().add("Kubernetes");

        // Original is NOT affected
        System.out.println(original.getName());           // Alice
        System.out.println(original.getAddress().getStreet()); // 123 Main St
        System.out.println(original.getSkills().size());  // 3
    }
}

public class ShapePrototypeRegistry {
    private final Map<String, Shape> prototypes = new HashMap<>();

    public ShapePrototypeRegistry() {
        // Pre-configure expensive prototypes
        Circle defaultCircle = new Circle();
        defaultCircle.setColor("red");
        defaultCircle.setRadius(10);
        prototypes.put("red-circle", defaultCircle);

        Rectangle defaultRect = new Rectangle();
        defaultRect.setColor("blue");
        defaultRect.setWidth(100);
        defaultRect.setHeight(50);
        prototypes.put("blue-rectangle", defaultRect);

        // Complex shape that takes expensive computation
        FractalShape fractal = new FractalShape();
        fractal.computeIterations(10000);  // Expensive!
        prototypes.put("fractal", fractal);
    }

    public Shape get(String key) {
        Shape prototype = prototypes.get(key);
        if (prototype == null) {
            throw new IllegalArgumentException("Unknown prototype: " + key);
        }
        return prototype.clone();  // Always return a copy!
    }

    public void register(String key, Shape prototype) {
        prototypes.put(key, prototype);
    }
}

// Usage — get copies without expensive setup
ShapePrototypeRegistry registry = new ShapePrototypeRegistry();

Shape circle1 = registry.get("red-circle");      // Instant clone
Shape circle2 = registry.get("red-circle");      // Another instant clone
Shape fractal = registry.get("fractal");          // Skip 10000 iterations!

public class Document implements Cloneable {
    private String title;
    private String content;
    private List<String> authors;
    private Map<String, String> metadata;

    public Document(String title, String content) {
        this.title = title;
        this.content = content;
        this.authors = new ArrayList<>();
        this.metadata = new HashMap<>();
    }

    public void addAuthor(String author) { authors.add(author); }
    public void addMetadata(String key, String value) { metadata.put(key, value); }

    @Override
    public Document clone() {
        try {
            Document clone = (Document) super.clone();  // Shallow copy
            // Deep copy mutable fields
            clone.authors = new ArrayList<>(this.authors);
            clone.metadata = new HashMap<>(this.metadata);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError("Should not happen", e);
        }
    }

    @Override
    public String toString() {
        return "Document{title='" + title + "', authors=" + authors + "}";
    }
}

// Usage
Document original = new Document("Design Patterns", "Chapter 1...");
original.addAuthor("Gang of Four");
original.addMetadata("version", "1.0");

Document copy = original.clone();
copy.addAuthor("New Author");

System.out.println(original);  // authors=[Gang of Four]
System.out.println(copy);      // authors=[Gang of Four, New Author]

public class GameState {
    private int score;
    private int level;
    private List<String> inventory;
    private Map<String, Integer> achievements;

    // Regular constructor
    public GameState(int level) {
        this.score = 0;
        this.level = level;
        this.inventory = new ArrayList<>();
        this.achievements = new HashMap<>();
    }

    // Copy constructor — explicit and clear
    public GameState(GameState other) {
        this.score = other.score;
        this.level = other.level;
        this.inventory = new ArrayList<>(other.inventory);
        this.achievements = new HashMap<>(other.achievements);
    }

    // Copy factory method — alternative style
    public static GameState copyOf(GameState other) {
        return new GameState(other);
    }

    // Mutators
    public void addScore(int points) { score += points; }
    public void addItem(String item) { inventory.add(item); }
    public void unlock(String achievement) { achievements.put(achievement, level); }
}

// Save game state before a risky action
GameState checkpoint = new GameState(currentState);  // Deep copy
try {
    currentState.enterBossFight();
} catch (GameOverException e) {
    currentState = checkpoint;  // Restore from copy
}