Introduction
The Prototype Pattern is a creational design pattern that lets you clone existing objects instead of creating new ones from scratch. This can be much more efficient—especially for resource-intensive or complex object creation.
Why Prototype Pattern Matters
In real-world applications, object creation might involve heavy computations, database operations, or complex configuration. Cloning an existing, pre-configured object can be faster and more efficient. It also helps decouple the instantiation logic from the client code.
Core Intent and Participants
- Intent: Create new objects by copying or cloning existing ones rather than instantiating new ones.
Participants
Prototype: Declares the interface for cloning itself.ConcretePrototype: Implements the clone operation.Client: Creates a new object by asking a prototype to clone itself.
UML Diagram (Text)
+----------------+
| Prototype |
+----------------+
| + clone(): P |
+----------------+
^
|
+--------------------+ +------------+
| ConcretePrototype |<------| Client |
+--------------------+ +------------+
| + clone(): P |
+--------------------+
Real-World Use Cases
- Game development (cloning characters, weapons)
- Document editors (duplicate templates)
- Object pools (reusable resource-heavy objects)
- GUI designers (copy-paste UI components)
- Caching pre-configured objects
Common Implementation Strategies in Java
Java’s Cloneable Interface
Java provides the Cloneable interface and Object.clone() method for shallow copying.
Example: Cloning a Shape Object
Step 1: Prototype Interface
public interface Prototype {
Prototype cloneObject();
}
Step 2: Concrete Prototype
public class Circle implements Prototype {
private int radius;
private String color;
public Circle(int radius, String color) {
this.radius = radius;
this.color = color;
}
@Override
public Circle cloneObject() {
return new Circle(this.radius, this.color);
}
@Override
public String toString() {
return "Circle [radius=" + radius + ", color=" + color + "]";
}
}
Step 3: Client Code
public class PrototypeDemo {
public static void main(String[] args) {
Circle original = new Circle(10, "Red");
Circle cloned = original.cloneObject();
System.out.println("Original: " + original);
System.out.println("Cloned: " + cloned);
}
}
✅ The cloned object is independent of the original.
Deep Copy vs Shallow Copy
- Shallow Copy: Copies object references for nested objects (default
clone()behavior) - Deep Copy: Recursively clones all nested objects to ensure full duplication
Deep Copy Example Using Serialization
public static <T extends Serializable> T deepCopy(T object) {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bos)) {
out.writeObject(object);
try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream in = new ObjectInputStream(bis)) {
return (T) in.readObject();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
Pros and Cons
✅ Pros
- Speeds up object creation
- Reduces subclass instantiation logic
- Simplifies configuration-heavy objects
❌ Cons
- Cloning via
Cloneableis error-prone and outdated - Deep copies are hard to implement correctly
- Hidden dependencies may get duplicated unexpectedly
Anti-Patterns and Misuse
- Using
clone()with mutable fields without deep copying - Relying solely on Java’s
Cloneable(prefer customcloneObject()method) - Not overriding
clone()properly (risk ofCloneNotSupportedException)
Prototype vs Factory vs Builder
| Pattern | Use Case | Object Count | Object Construction | Use When... |
|---|---|---|---|---|
| Prototype | Clone from existing object | One at a time | Copy-based | Object is expensive to create |
| Factory | Create based on input/logic | Many | Logic-based | Type is known at runtime |
| Builder | Step-by-step for complex objects | One | Process-based | Object has many optional fields |
Refactoring Legacy Code
Before (Manual Cloning)
Shape shape2 = new Shape();
shape2.setColor(shape1.getColor());
shape2.setBorder(shape1.getBorder());
shape2.setWidth(shape1.getWidth());
After Using Prototype
Shape shape2 = shape1.cloneObject();
✅ Cleaner, reusable, and maintainable.
Best Practices
- Avoid using Java’s
Cloneablefor new code - Prefer custom interfaces like
Prototype.cloneObject() - Document whether cloning is deep or shallow
- Ensure immutability where possible
Real-World Analogy
Think of a photocopy machine. Instead of rewriting a document from scratch, you take an existing document and copy it instantly. Each copy is independent but structurally identical.
Java Version Relevance
- Java 8+: Use serialization for deep copy
- Java 14+: Use records for shallow immutable cloning
- Java 17+: Sealed classes can restrict cloning hierarchies
Conclusion & Key Takeaways
- The Prototype Pattern enables object cloning with better performance.
- Great for large or expensive-to-create objects.
- Avoid pitfalls of shallow copying and use deep copy when needed.
- Prefer writing your own
cloneObject()instead of usingCloneable.
FAQ – Prototype Pattern in Java
1. What is the Prototype Pattern?
A creational design pattern where new objects are created by copying existing ones.
2. When is it useful?
When object creation is expensive or repeated with minor differences.
3. Is Java’s Cloneable a good choice?
It works but is outdated. Custom cloning is preferred.
4. What’s the difference between shallow and deep copy?
Shallow copies references; deep copies actual objects recursively.
5. Can it be used for immutable objects?
Yes, though less beneficial since immutables don’t need frequent copying.
6. What’s a real-world use case?
Cloning UI components, enemy templates in games, or document templates.
7. How do I avoid CloneNotSupportedException?
Override clone() properly and implement Cloneable if using native API.
8. Can I use serialization for deep copy?
Yes, it’s a common method.
9. Is Prototype better than Factory?
Not always—use Prototype when copying is cheaper than creating.
10. Can it work with abstract classes?
Yes, the prototype can be defined in abstract class or interface.