Java Implementation Memo Mode
The memo pattern is a behavioral design pattern used to capture the internal state of an object and restore it when needed, without exposing the implementation details of the object. This pattern encapsulates the object state in a memo object, enabling the storage and recovery of the object state, while also preventing external code from directly accessing the object's state.
Applicable scenario:
When it is necessary to save and restore the internal state of an object, memo mode can be used. For example, in an application, a user can undo some actions, which requires saving the state of the object for recovery when needed.
When you want to encapsulate the state of an object and prevent external code from directly accessing its state, you can use memo mode.
Benefits:
1. It provides the ability to save and restore object states, making object state management more convenient and flexible.
Encapsulating the object state in a memo object can prevent external code from directly accessing the object's state, increasing the encapsulation and security of the object.
The following is a complete sample code for a Java based memo mode:
Firstly, we need to create a Memonto class to store the state of the object:
public class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
Then, we need to create an original object (Originator) for creating a memo and restoring the state:
public class Originator {
private String state;
public void setState(String state) {
this.state = state;
}
public Memento saveStateToMemento() {
return new Memento(state);
}
public void restoreStateFromMemento(Memento memento) {
this.state = memento.getState();
}
}
Finally, we need to create a Caretaker to manage memo objects:
public class Caretaker {
private List<Memento> mementoList = new ArrayList<>();
public void addMemento(Memento memento) {
mementoList.add(memento);
}
public Memento getMemento(int index) {
return mementoList.get(index);
}
}
An example of using memo mode is as follows:
public class Main {
public static void main(String[] args) {
Originator originator = new Originator();
Caretaker caretaker = new Caretaker();
originator.setState("State1");
originator.setState("State2");
caretaker.addMemento(originator.saveStateToMemento());
originator.setState("State3");
caretaker.addMemento(originator.saveStateToMemento());
originator.setState("State4");
System.out.println("Current state: " + originator.getState());
originator.restoreStateFromMemento(caretaker.getMemento(0));
System.out.println("Restored state: " + originator.getState());
}
}
Run the above code and the output result is:
Current state: State4
Restored state: State2
In this example, the Originator saves memo objects in different states, while the Caretaker is used to save and retrieve memo objects. By saving and restoring the internal state of an object, we can restore it to its previous state at any time.
