forked from BruceEckel/OnJava8-Examples
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathObservedFlower.java
More file actions
123 lines (119 loc) · 3.5 KB
/
ObservedFlower.java
File metadata and controls
123 lines (119 loc) · 3.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
// patterns/observer/ObservedFlower.java
// (c)2021 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
// Demonstration of the Observer pattern.
// {java patterns.observer.ObservedFlower}
package patterns.observer;
import java.util.*;
import java.util.function.*;
@SuppressWarnings("deprecation")
class Flower {
private boolean isOpen = false;
private boolean alreadyOpen = false;
private boolean alreadyClosed = false;
Observable opening = new Observable() {
@Override public void notifyObservers() {
if(isOpen && !alreadyOpen) {
setChanged();
super.notifyObservers();
alreadyOpen = true;
}
}
};
Observable closing = new Observable() {
@Override public void notifyObservers() {
if(!isOpen && !alreadyClosed) {
setChanged();
super.notifyObservers();
alreadyClosed = true;
}
}
};
public void open() { // Opens its petals
isOpen = true;
opening.notifyObservers();
alreadyClosed = false;
}
public void close() { // Closes its petals
isOpen = false;
closing.notifyObservers();
alreadyOpen = false;
}
}
@SuppressWarnings("deprecation")
class Bee {
private String id;
Bee(String name) { id = name; }
// Observe openings:
public final Observer whenOpened = (ob, a) ->
System.out.println(
"Bee " + id + "'s breakfast time!");
// Observe closings:
public final Observer whenClosed = (ob, a) ->
System.out.println(
"Bee " + id + "'s bed time!");
}
@SuppressWarnings("deprecation")
class Hummingbird {
private String id;
Hummingbird(String name) { id = name; }
public final Observer whenOpened = (ob, a) ->
System.out.println("Hummingbird " +
id + "'s breakfast time!");
public final Observer whenClosed = (ob, a) ->
System.out.println("Hummingbird " +
id + "'s bed time!");
}
public class ObservedFlower {
public static void main(String[] args) {
Flower f = new Flower();
Bee
ba = new Bee("A"),
bb = new Bee("B");
Hummingbird
ha = new Hummingbird("A"),
hb = new Hummingbird("B");
f.opening.addObserver(ha.whenOpened);
f.opening.addObserver(hb.whenOpened);
f.opening.addObserver(ba.whenOpened);
f.opening.addObserver(bb.whenOpened);
f.closing.addObserver(ha.whenClosed);
f.closing.addObserver(hb.whenClosed);
f.closing.addObserver(ba.whenClosed);
f.closing.addObserver(bb.whenClosed);
// Hummingbird B decides to sleep in.
// Removing whenOpened stops open updates.
f.opening.deleteObserver(hb.whenOpened);
// A change that interests observers:
f.open();
f.open(); // No effect: it's already open.
System.out.println("---------------");
// Bee A doesn't want to go to bed.
// Removing whenClosed stops close updates.
f.closing.deleteObserver(ba.whenClosed);
f.close();
System.out.println("+++++++++++++++");
f.close(); // No effect: it's already closed.
System.out.println("===============");
f.opening.deleteObservers();
f.open(); // No observers to update.
System.out.println("###############");
f.close(); // Close observers are still there.
}
}
/* Output:
Bee B's breakfast time!
Bee A's breakfast time!
Hummingbird A's breakfast time!
---------------
Bee B's bed time!
Hummingbird B's bed time!
Hummingbird A's bed time!
+++++++++++++++
===============
###############
Bee B's bed time!
Hummingbird B's bed time!
Hummingbird A's bed time!
*/