FilesExpand file tree

 master

/

ObservedFlower.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

122 lines (118 loc) · 3.25 KB

 master

/

ObservedFlower.java

Copy path

Top

File metadata and controls

• Code
• Blame

122 lines (118 loc) · 3.25 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

// patterns/observer/ObservedFlower.java

// (c)2017 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 "Observer" pattern

// {java patterns.observer.ObservedFlower}

package patterns.observer;

import java.util.*;

class Flower {

private boolean isOpen;

private boolean alreadyOpen;

private boolean alreadyClosed;

Flower() { isOpen = false; }

OpenNotifier opening = new OpenNotifier();

CloseNotifier closing = new CloseNotifier();

public void open() { // Opens its petals

isOpen = true;

opening.notifyObservers();

alreadyClosed = false;

}

public void close() { // Closes its petals

isOpen = false;

closing.notifyObservers();

alreadyOpen = false;

}

class OpenNotifier extends Observable {

@Override

public void notifyObservers() {

if(isOpen && !alreadyOpen) {

setChanged();

super.notifyObservers();

alreadyOpen = true;

}

}

}

class CloseNotifier extends Observable{

@Override

public void notifyObservers() {

if(!isOpen && !alreadyClosed) {

setChanged();

super.notifyObservers();

alreadyClosed = true;

}

}

}

}

class Bee {

private String name;

Bee(String nm) { name = nm; }

// Observe openings:

public Observer openObserver() {

return (ob, a) -> System.out.println(

"Bee " + name + "'s breakfast time!");

}

// Observe closings:

public Observer closeObserver() {

return (ob, a) -> System.out.println(

"Bee " + name + "'s bed time!");

}

}

class Hummingbird {

private String name;

Hummingbird(String nm) { name = nm; }

public Observer openObserver() {

return (ob, a) -> System.out.println(

"Hummingbird " + name +

"'s breakfast time!");

}

public Observer closeObserver() {

return (ob, a) -> System.out.println(

"Hummingbird " + name + "'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.openObserver());

f.opening.addObserver(hb.openObserver());

f.opening.addObserver(ba.openObserver());

f.opening.addObserver(bb.openObserver());

f.closing.addObserver(ha.closeObserver());

f.closing.addObserver(hb.closeObserver());

f.closing.addObserver(ba.closeObserver());

f.closing.addObserver(bb.closeObserver());

// Hummingbird B decides to sleep in:

f.opening.deleteObserver(hb.openObserver());

// A change that interests observers:

f.open();

f.open(); // It's already open, no change.

// Bee A doesn't want to go to bed:

f.closing.deleteObserver(ba.closeObserver());

f.close();

f.close(); // It's already closed; no change

f.opening.deleteObservers();

f.open();

f.close();

}

}

/* Output:

Bee B's breakfast time!

Bee A's breakfast time!

Hummingbird B's breakfast time!

Hummingbird A's breakfast time!

Bee B's bed time!

Bee A's bed time!

Hummingbird B's bed time!

Hummingbird A's bed time!

Bee B's bed time!

Bee A's bed time!

Hummingbird B's bed time!

Hummingbird A's bed time!

*/