Behavioral Patterns - Applied Java Patterns - page 60

In this example, the observable element is represented by the Task being modified in the GUI. The class
TaskChangeObservable keeps track of the listeners for changes to the Task through the methods
addTaskChangeObserver and removeTaskChangeObserver .
Example 2.32 TaskChangeObservable.java
1. import java.util.ArrayList;
2. import java.util.Iterator;
3. public class TaskChangeObservable{
4. private ArrayList observers = new ArrayList();
5.
6. public void addTaskChangeObserver(TaskChangeObserver observer){
7. if (!observers.contains(observer)){
8. observers.add(observer);
9. }
10. }
11. public void removeTaskChangeObserver(TaskChangeObserver observer){
12. observers.remove(observer);
13. }
14.
15. public void selectTask(Task task){
16. Iterator elements = observers.iterator();
17. while (elements.hasNext()){
18. ((TaskChangeObserver)elements.next()).taskSelected(task);
19. }
20. }
21. public void addTask(Task task){
22. Iterator elements = observers.iterator();
23. while (elements.hasNext()){
24. ((TaskChangeObserver)elements.next()).taskAdded(task);
25. }
26. }
27. public void updateTask(Task task){
28. Iterator elements = observers.iterator();
29. while (elements.hasNext()){
30. ((TaskChangeObserver)elements.next()).taskChanged(task);
31. }
32. }
33. }
TaskChangeObservable has the business methods selectTask , updateTask , and addTask . These methods send
notifications of any changes to a Task .
Every observer must implement the TaskChangeObserver interface, allowing the TaskChangeObservable to call
the appropriate method on each observer. If a client were to call the method addTask on the
TaskChangeObservable , for instance, the observable object would iterate through its observers and call the
taskAdded method on each.
Example 2.33 TaskChangeObserver.java
1. public interface TaskChangeObserver{
2. public void taskAdded(Task task);
3. public void taskChanged(Task task);
4. public void taskSelected(Task task);
5. }
The class ObserverGui provides a GUI in this demonstration, and creates a TaskChangeObservable object. In
addition, it creates three panels that implement the TaskChangeObserver interface, and matches them with the
TaskChangeObservable object. By doing this, the TaskChangeObservable is able to effectively send updates
among the three panels of the GUI.
Example 2.34 ObserverGui.java
1. import java.awt.Container;
2. import java.awt.event.WindowAdapter;
3. import java.awt.event.WindowEvent;
4. import javax.swing.BoxLayout;
5. import javax.swing.JFrame;
6. public class ObserverGui{
7. public void createGui(){
8. JFrame mainFrame = new JFrame("Observer Pattern Example");
9. Container content = mainFrame.getContentPane();
10. content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
11. TaskChangeObservable observable = new TaskChangeObservable();