Design pattern - Iterator, Mediator and Memento

1. Design Pattern
Iterator、Mediator、Memento
Sean Tsai 2015.11.10

2. Iterator
Provide a way to access the elements of an aggregate object
sequentially without exposing its underlying representation.
Also knowns as Cursor

3. Sample - McDonald’s + KFC
Iterator

4. Sample - McDonald’s + KFC
McDonaldMenu mcDonaldMenu = new McDonaldMenu();
ArrayList breakfastItems = mcDonaldMenu.getMenuItems();
KFCMenu kfcMenu = new KFCMenu();
MenuItem[] lunchItems = dinerMenu.getMenuItems();
Iterator

5. Sample - McDonald’s + KFC
Iterator

6. Sample - McDonald’s + KFC
for (int i = 0; i < breakfastItems.size(); i++) {
MenuItem menuItem = (MenuItem)breakfastItems.get(i);
System.out.print(menuItem.getName() + “ “);
System.out.println(menuItem.getPrice() + “ “);
System.out.println(menuItem.getDescription());
}
for (int i = 0; i < lunchItems.length; i++) {
MenuItem menuItem = lunchItems[i];
System.out.print(menuItem.getName() + “ “);
System.out.println(menuItem.getPrice() + “ “);
System.out.println(menuItem.getDescription());
}
Iterator

7. Diagram
Iterator

8. Pros and Cons
Pros:
● It supports variations in the traversal of an aggregate.
● Iterators simplify the Aggregate interface.
Iterator

9. Mediator
Mediator pattern is used to reduce communication complexity
between multiple objects or classes.

10. Sample 1 - Unix System
Mediator

11. Sample 2 - Control Tower
Mediator

12. Sample 3 - Dialog box
MediatorMediator

13. Diagram
Mediator

14. Pros and Cons
Pros:
● Limit subclassing and specialization.
● Decouples colleagues.
Cons:
● Reducing the complexity of colleagues increases the complexity of the
Mediator itself.
Mediator

15. Memento
Memento pattern is used to restore state of an object to a previous
state. Memento pattern falls under behavioral pattern category.

16. Diagram
Memento

17. Sample Code
public class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
Memento

18. Sample Code
public class Originator {
private String state;
public void setState(String state) {
this.state = state;
}
public String getState() {
return state;
}
public Memento saveStateToMemento() {
return new Memento(state);
}
public void getStateFromMemento(Memento Memento) {
state = Memento.getState();
}
}
Memento

19. Sample Code
Memento
import java.util.ArrayList;
import java.util.List;
public class CareTaker {
private List<Memento> mementoList = new ArrayList<Memento>();
public void add(Memento state){
mementoList.add(state);
}
public Memento get(int index){
return mementoList.get(index);
}
}

20. Diagram
Mediator
public class MementoPatternDemo {
public static void main(String[] args) {
Originator originator = new Originator();
CareTaker careTaker = new CareTaker();
originator.setState("State #1");
originator.setState("State #2");
careTaker.add(originator.saveStateToMemento());
originator.setState("State #3");
careTaker.add(originator.saveStateToMemento());
originator.setState("State #4");
System.out.println("Current State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(0));
System.out.println("First saved State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(1));
System.out.println("Second saved State: " + originator.getState());
}
}

21. Sample Code
Memento
import java.util.ArrayList;
import java.util.List;
public class CareTaker {
private List<Memento> mementoList =
new ArrayList<Memento>();
public void add(Memento state){
mementoList.add(state);
}
public Memento get(int index){
return mementoList.get(index);
}
}

22. Pros and Cons
Memento
Pros:
● The history is maintained without knowing what changed inside the
object.
Cons:
● Using mementos might be expensive.
● It may be difficult in some languages to ensure that only the originator can
access the memento's state.

23. End