Memento Design pattern - Class Diagram

🚀 Master Java Design Patterns & Software Architecture!

Subscribe to Ram N Java for clean software architecture patterns, design pattern deep dives, and production-ready implementation guides!

🔔 Subscribe to Ram N Java

Understanding the Memento Design Pattern Class Diagram

The Memento Design Pattern is a behavioral pattern that allows an application to capture and restore the internal state of an object without exposing its private implementation details. To implement this pattern cleanly in object-oriented systems, it is essential to master its structural architecture. A Unified Modeling Language (UML) class diagram provides a clear blueprint detailing how the Originator, Memento, and Caretaker classes interact while preserving encapsulation boundaries.

Key Structural Components in UML

• Originator: The primary business class containing mutable state. In the class diagram, it exposes methods such as createMemento() to produce state snapshots and restore(Memento) to restore past state.
• Memento: The passive state container holding a snapshot of the Originator’s fields. It is modeled to have narrow visibility towards external components and wide access for the Originator.
• Caretaker: The manager responsible for safe-keeping snapshots (e.g., maintaining an undo/redo stack or history collection). It never inspects, modifies, or accesses internal memento data.

Relationships and Architectural Roles

1. Dependency / Instantiation: The Originator instantiates and interacts with the Memento, populating it with snapshot data and consuming it during state restoration.
2. Aggregation / Association: The Caretaker holds an aggregation reference (often a List<Memento> or Stack<Memento>) to preserve historical checkpoints over time.
3. Encapsulation Shielding: The Caretaker interacts only with the Memento through a narrow interface (or treats it as an opaque token), ensuring private state attributes remain hidden.

Architectural Advantages

• Encapsulation Preservation: Eliminates the need for public getters and setters on sensitive internal state fields purely for persistence or undo purposes.
• Single Responsibility Principle (SRP): Keeps history tracking, stack management, and storage lifecycles isolated in the Caretaker, leaving the Originator focused strictly on core business rules.
• Modular & Extensible: Checkpoint storage strategies (e.g., file caching, memory stacks, or distributed persistence) can be modified without altering the Originator.

Recommended Next Videos

Continue your deep dive into the Memento pattern and behavioral design patterns with these related tutorials from our channel:

• Memento Design Pattern: A Fundamental Overview
• Memento Design Pattern: Sequence Diagram Explained
• Memento Design Pattern Implementation: Code Walkthrough
• Memento Design Pattern: Key Points

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=O-VSseHwhcA

Click the below Image to Enlarge

Memento Design pattern - Class Diagram

See also:

Momento Design pattern - Introduction

Momento Design pattern - Real time Example

Memento Design pattern - Sequence Diagram

Memento Design pattern - Implementation

Momento Design pattern - KeyPoints

All Design Patterns Links