Prototype Pattern Implementation in Java

The Prototype Pattern is a creational design pattern that allows you to create new objects by copying existing objects (prototypes) without depending on their classes. This pattern is particularly useful when object creation is expensive or complex.

Key Concepts

Prototype Interface: Declares the cloning method
Concrete Prototype: Implements the cloning method
Client: Creates new objects by copying prototypes

Basic Implementation

Example 1: Basic Prototype Pattern

// Prototype interface interface Prototype extends Cloneable { Prototype clone() throws CloneNotSupportedException; void display(); } // Concrete prototype class ConcretePrototype implements Prototype { private String name; private int value; public ConcretePrototype(String name, int value) { this.name = name; this.value = value; System.out.println("Original object created with complex initialization..."); simulateExpensiveOperation(); } private void simulateExpensiveOperation() { try { Thread.sleep(1000); // Simulate expensive operation } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } // Copy constructor for deep cloning public ConcretePrototype(ConcretePrototype prototype) { this.name = prototype.name; this.value = prototype.value; } @Override public Prototype clone() throws CloneNotSupportedException { // Shallow clone return (ConcretePrototype) super.clone(); } public Prototype deepClone() { // Deep clone using copy constructor return new ConcretePrototype(this); } @Override public void display() { System.out.println("Prototype [name=" + name + ", value=" + value + ", hashCode=" + hashCode() + "]"); } // Getters and setters public String getName() { return name; } public void setName(String name) { this.name = name; } public int getValue() { return value; } public void setValue(int value) { this.value = value; } } // Client code public class PrototypeBasicDemo { public static void main(String[] args) throws CloneNotSupportedException { // Create original object (expensive operation) ConcretePrototype original = new ConcretePrototype("Original", 100); original.display(); // Create clone (cheap operation) ConcretePrototype clone = (ConcretePrototype) original.clone(); clone.setName("Clone"); clone.display(); // Create deep clone ConcretePrototype deepClone = (ConcretePrototype) original.deepClone(); deepClone.setName("Deep Clone"); deepClone.display(); } }

Advanced Prototype Pattern with Registry

Example 2: Prototype Registry

import java.util.HashMap; import java.util.Map; // Prototype registry class PrototypeRegistry { private Map<String, Prototype> prototypes = new HashMap<>(); public void registerPrototype(String key, Prototype prototype) { prototypes.put(key, prototype); } public Prototype getPrototype(String key) throws CloneNotSupportedException { Prototype prototype = prototypes.get(key); if (prototype != null) { return prototype.clone(); } throw new IllegalArgumentException("Prototype not found for key: " + key); } public void loadDefaults() { registerPrototype("basic", new ConcretePrototype("Basic", 1)); registerPrototype("advanced", new ConcretePrototype("Advanced", 2)); registerPrototype("premium", new ConcretePrototype("Premium", 3)); } } // Enhanced prototype with different types class DocumentPrototype implements Prototype { private String title; private String content; private String author; private DocumentType type; private Map<String, String> metadata; public DocumentPrototype(String title, String content, String author, DocumentType type) { this.title = title; this.content = content; this.author = author; this.type = type; this.metadata = new HashMap<>(); simulateDocumentLoading(); } // Copy constructor public DocumentPrototype(DocumentPrototype prototype) { this.title = prototype.title; this.content = prototype.content; this.author = prototype.author; this.type = prototype.type; this.metadata = new HashMap<>(prototype.metadata); // Deep copy } private void simulateDocumentLoading() { System.out.println("Loading document: " + title); try { Thread.sleep(500); // Simulate document loading time } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } @Override public Prototype clone() throws CloneNotSupportedException { // Shallow clone - be careful with mutable objects! return (DocumentPrototype) super.clone(); } public Prototype deepClone() { return new DocumentPrototype(this); } @Override public void display() { System.out.println("Document [title=" + title + ", type=" + type + ", author=" + author + ", contentLength=" + content.length() + ", metadata=" + metadata + "]"); } // Business methods public void addMetadata(String key, String value) { metadata.put(key, value); } public void updateContent(String newContent) { this.content = newContent; } // Getters and setters public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public DocumentType getType() { return type; } } enum DocumentType { REPORT, CONTRACT, PRESENTATION, EMAIL } // Usage example public class PrototypeRegistryDemo { public static void main(String[] args) throws CloneNotSupportedException { PrototypeRegistry registry = new PrototypeRegistry(); registry.loadDefaults(); // Create documents from prototypes DocumentPrototype reportTemplate = new DocumentPrototype( "Monthly Report", "This is a template for monthly reports.", "System", DocumentType.REPORT ); reportTemplate.addMetadata("category", "finance"); reportTemplate.addMetadata("version", "1.0"); registry.registerPrototype("monthly-report", reportTemplate); // Clone prototypes to create new instances DocumentPrototype janReport = (DocumentPrototype) registry.getPrototype("monthly-report"); janReport.setTitle("January 2024 Monthly Report"); janReport.setAuthor("John Doe"); janReport.updateContent("January was a great month for sales..."); janReport.addMetadata("period", "January 2024"); janReport.display(); DocumentPrototype febReport = (DocumentPrototype) registry.getPrototype("monthly-report"); febReport.setTitle("February 2024 Monthly Report"); febReport.setAuthor("Jane Smith"); febReport.updateContent("February showed steady growth..."); febReport.addMetadata("period", "February 2024"); febReport.display(); } }

Real-World Example: Graphic Shapes

Example 3: Graphic Editor with Prototype Pattern

import java.awt.*; import java.util.ArrayList; import java.util.List; // Abstract shape prototype abstract class Shape implements Cloneable { protected int x; protected int y; protected Color color; protected boolean selected; public Shape(int x, int y, Color color) { this.x = x; this.y = y; this.color = color; this.selected = false; } // Copy constructor for deep cloning public Shape(Shape shape) { this.x = shape.x; this.y = shape.y; this.color = shape.color; this.selected = shape.selected; } @Override public Shape clone() throws CloneNotSupportedException { return (Shape) super.clone(); } public abstract Shape deepClone(); public abstract void draw(Graphics g); public abstract boolean contains(int x, int y); // Common operations public void move(int dx, int dy) { this.x += dx; this.y += dy; } public void setSelected(boolean selected) { this.selected = selected; } // Getters and setters public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public Color getColor() { return color; } public void setColor(Color color) { this.color = color; } } // Concrete shape: Circle class Circle extends Shape { private int radius; public Circle(int x, int y, int radius, Color color) { super(x, y, color); this.radius = radius; } // Copy constructor public Circle(Circle circle) { super(circle); this.radius = circle.radius; } @Override public Shape deepClone() { return new Circle(this); } @Override public void draw(Graphics g) { g.setColor(color); g.fillOval(x - radius, y - radius, radius * 2, radius * 2); if (selected) { g.setColor(Color.RED); g.drawOval(x - radius, y - radius, radius * 2, radius * 2); } } @Override public boolean contains(int pointX, int pointY) { int dx = pointX - x; int dy = pointY - y; return dx * dx + dy * dy <= radius * radius; } public int getRadius() { return radius; } public void setRadius(int radius) { this.radius = radius; } } // Concrete shape: Rectangle class Rectangle extends Shape { private int width; private int height; public Rectangle(int x, int y, int width, int height, Color color) { super(x, y, color); this.width = width; this.height = height; } // Copy constructor public Rectangle(Rectangle rectangle) { super(rectangle); this.width = rectangle.width; this.height = rectangle.height; } @Override public Shape deepClone() { return new Rectangle(this); } @Override public void draw(Graphics g) { g.setColor(color); g.fillRect(x, y, width, height); if (selected) { g.setColor(Color.RED); g.drawRect(x, y, width, height); } } @Override public boolean contains(int pointX, int pointY) { return pointX >= x && pointX <= x + width && pointY >= y && pointY <= y + height; } public int getWidth() { return width; } public void setWidth(int width) { this.width = width; } public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } } // Graphic editor using prototype pattern class GraphicEditor { private List<Shape> shapes = new ArrayList<>(); private Shape selectedShape; public void addShape(Shape shape) { shapes.add(shape); } public void selectShape(int x, int y) { // Deselect all shapes shapes.forEach(shape -> shape.setSelected(false)); selectedShape = null; // Find and select clicked shape for (int i = shapes.size() - 1; i >= 0; i--) { Shape shape = shapes.get(i); if (shape.contains(x, y)) { shape.setSelected(true); selectedShape = shape; break; } } } public void duplicateSelectedShape() { if (selectedShape != null) { try { Shape clone = selectedShape.deepClone(); clone.move(20, 20); // Offset the clone shapes.add(clone); selectedShape.setSelected(false); clone.setSelected(true); selectedShape = clone; } catch (Exception e) { e.printStackTrace(); } } } public void drawAll(Graphics g) { shapes.forEach(shape -> shape.draw(g)); } public List<Shape> getShapes() { return shapes; } } // Demo application public class GraphicEditorDemo { public static void main(String[] args) { // Create prototype shapes Circle circlePrototype = new Circle(100, 100, 30, Color.BLUE); Rectangle rectanglePrototype = new Rectangle(200, 100, 80, 60, Color.GREEN); GraphicEditor editor = new GraphicEditor(); // Add original shapes editor.addShape(circlePrototype); editor.addShape(rectanglePrototype); // Select and duplicate shapes editor.selectShape(100, 100); // Select circle editor.duplicateSelectedShape(); // Duplicate circle editor.selectShape(200, 100); // Select rectangle editor.duplicateSelectedShape(); // Duplicate rectangle // Display results System.out.println("Total shapes: " + editor.getShapes().size()); editor.getShapes().forEach(shape -> { System.out.println(shape.getClass().getSimpleName() + " at (" + shape.getX() + ", " + shape.getY() + ")"); }); } }

Database Entity Prototypes

Example 4: Database Entity Cloning

import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; import java.util.UUID; // Base entity prototype abstract class Entity implements Cloneable { protected String id; protected LocalDateTime createdAt; protected LocalDateTime updatedAt; protected String createdBy; public Entity() { this.id = UUID.randomUUID().toString(); this.createdAt = LocalDateTime.now(); } // Copy constructor public Entity(Entity entity) { this.id = UUID.randomUUID().toString(); // New ID for clone this.createdAt = LocalDateTime.now(); this.updatedAt = entity.updatedAt; this.createdBy = entity.createdBy; } @Override public Entity clone() throws CloneNotSupportedException { return (Entity) super.clone(); } public abstract Entity deepClone(); // Getters and setters public String getId() { return id; } public LocalDateTime getCreatedAt() { return createdAt; } public LocalDateTime getUpdatedAt() { return updatedAt; } public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; } public String getCreatedBy() { return createdBy; } public void setCreatedBy(String createdBy) { this.createdBy = createdBy; } } // User entity class User extends Entity { private String username; private String email; private List<String> roles; private UserProfile profile; public User(String username, String email) { super(); this.username = username; this.email = email; this.roles = new ArrayList<>(); this.profile = new UserProfile(); } // Copy constructor for deep cloning public User(User user) { super(user); this.username = user.username; this.email = user.email; this.roles = new ArrayList<>(user.roles); // Deep copy this.profile = user.profile.deepClone(); // Deep copy } @Override public User deepClone() { return new User(this); } public void addRole(String role) { roles.add(role); } // Getters and setters public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public List<String> getRoles() { return new ArrayList<>(roles); } public void setRoles(List<String> roles) { this.roles = new ArrayList<>(roles); } public UserProfile getProfile() { return profile; } public void setProfile(UserProfile profile) { this.profile = profile; } @Override public String toString() { return "User{id='" + id + "', username='" + username + "', email='" + email + "', roles=" + roles + ", profile=" + profile + "}"; } } // User profile (complex nested object) class UserProfile implements Cloneable { private String firstName; private String lastName; private String phone; private Address address; public UserProfile() { this.address = new Address(); } // Copy constructor public UserProfile(UserProfile profile) { this.firstName = profile.firstName; this.lastName = profile.lastName; this.phone = profile.phone; this.address = profile.address.deepClone(); // Deep copy } public UserProfile deepClone() { return new UserProfile(this); } @Override public UserProfile clone() throws CloneNotSupportedException { UserProfile clone = (UserProfile) super.clone(); clone.address = this.address.clone(); return clone; } // Getters and setters public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } @Override public String toString() { return "UserProfile{firstName='" + firstName + "', lastName='" + lastName + "', phone='" + phone + "', address=" + address + "}"; } } // Address class class Address implements Cloneable { private String street; private String city; private String zipCode; public Address deepClone() { try { return (Address) this.clone(); } catch (CloneNotSupportedException e) { throw new RuntimeException("Cloning not supported", e); } } @Override public Address clone() throws CloneNotSupportedException { return (Address) super.clone(); } // 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 getZipCode() { return zipCode; } public void setZipCode(String zipCode) { this.zipCode = zipCode; } @Override public String toString() { return "Address{street='" + street + "', city='" + city + "', zipCode='" + zipCode + "'}"; } } // Entity factory using prototype pattern class EntityFactory { private User adminUserPrototype; private User guestUserPrototype; public EntityFactory() { // Create prototype instances adminUserPrototype = new User("admin", "[email protected]"); adminUserPrototype.addRole("ADMIN"); adminUserPrototype.addRole("USER"); adminUserPrototype.getProfile().setFirstName("System"); adminUserPrototype.getProfile().setLastName("Administrator"); guestUserPrototype = new User("guest", "[email protected]"); guestUserPrototype.addRole("GUEST"); } public User createAdminUser() { User admin = adminUserPrototype.deepClone(); admin.setCreatedBy("system"); return admin; } public User createGuestUser() { User guest = guestUserPrototype.deepClone(); guest.setCreatedBy("system"); return guest; } public User createUserWithProfile(String username, String email, UserProfile profile) { User user = new User(username, email); user.setProfile(profile.deepClone()); user.addRole("USER"); return user; } } // Demo public class EntityPrototypeDemo { public static void main(String[] args) { EntityFactory factory = new EntityFactory(); // Create users from prototypes User admin1 = factory.createAdminUser(); admin1.setUsername("admin1"); admin1.setEmail("[email protected]"); User admin2 = factory.createAdminUser(); admin2.setUsername("admin2"); admin2.setEmail("[email protected]"); User guest = factory.createGuestUser(); guest.setUsername("temporary_guest"); // Create user with custom profile UserProfile profile = new UserProfile(); profile.setFirstName("John"); profile.setLastName("Doe"); profile.getAddress().setCity("New York"); User customUser = factory.createUserWithProfile("johndoe", "[email protected]", profile); // Display users System.out.println("Admin 1: " + admin1); System.out.println("Admin 2: " + admin2); System.out.println("Guest: " + guest); System.out.println("Custom User: " + customUser); // Verify they have different IDs (different objects) System.out.println("\nDifferent IDs: " + (!admin1.getId().equals(admin2.getId()) && !guest.getId().equals(customUser.getId()))); } }

Performance Considerations

Example 5: Prototype vs New Object Creation

public class PerformanceComparison { static class ExpensiveObject implements Cloneable { private byte[] data; public ExpensiveObject() { // Simulate expensive initialization this.data = new byte[1024 * 1024]; // 1MB initializeData(); } // Copy constructor for prototype public ExpensiveObject(ExpensiveObject prototype) { this.data = prototype.data.clone(); // Copy array } private void initializeData() { // Simulate expensive computation for (int i = 0; i < data.length; i++) { data[i] = (byte) (i % 256); } try { Thread.sleep(100); // Simulate computation time } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } @Override public ExpensiveObject clone() throws CloneNotSupportedException { return (ExpensiveObject) super.clone(); // Shallow clone } public ExpensiveObject deepClone() { return new ExpensiveObject(this); } } public static void main(String[] args) throws CloneNotSupportedException { int iterations = 100; // Test creating new objects long startTime = System.currentTimeMillis(); for (int i = 0; i < iterations; i++) { ExpensiveObject obj = new ExpensiveObject(); } long newObjectTime = System.currentTimeMillis() - startTime; // Test cloning from prototype ExpensiveObject prototype = new ExpensiveObject(); startTime = System.currentTimeMillis(); for (int i = 0; i < iterations; i++) { ExpensiveObject clone = prototype.deepClone(); } long cloneTime = System.currentTimeMillis() - startTime; System.out.println("Time to create " + iterations + " new objects: " + newObjectTime + "ms"); System.out.println("Time to create " + iterations + " clones: " + cloneTime + "ms"); System.out.println("Performance improvement: " + ((double) newObjectTime / cloneTime) + "x faster"); } }

Best Practices and Considerations

1. Deep vs Shallow Copy

// Shallow copy - be careful with mutable objects! @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } // Deep copy - safer but more expensive public Prototype deepClone() { return new ConcretePrototype(this); }

2. Using Copy Constructors

// Prefer copy constructors over Cloneable public class MyClass { public MyClass(MyClass other) { // Copy all fields, including deep copies of mutable objects } }

3. Registry Pattern

// Maintain a registry of prototypes class PrototypeRegistry { private Map<String, Prototype> registry = new HashMap<>(); public void register(String key, Prototype prototype) { registry.put(key, prototype); } public Prototype create(String key) { return registry.get(key).clone(); } }

When to Use Prototype Pattern

Object creation is expensive (database calls, network operations)
System should be independent of how objects are created
Classes to instantiate are specified at runtime
Avoid building class hierarchy of factories
Need to avoid constructor complexity

Advantages and Disadvantages

Advantages:

Reduces subclassing
Hides complexity of object creation
Can add/remove objects at runtime
Improves performance when object creation is expensive

Disadvantages:

Complex object copying (deep vs shallow)
Circular references can be problematic
Requires careful implementation for mutable objects

The Prototype Pattern is particularly useful in scenarios like graphic editors, game development, and enterprise applications where you need to create multiple similar objects with minor variations.