Design Patterns 1: Templates Methods, Abstract Factories, Observer/Listener

Transcription

1 1 / 1 Design Patterns 1: Templates Methods, Abstract Factories, Observer/Listener Yoav Goldberg Bar Ilan University

2 Design Patterns 2 / 1

3 3 / 1

4 each pattern describes a problem which occurs over and over again in out environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over and over, without ever doing it the same way twice. Christopher Alexander, GoF, p.2 4 / 1

5 4 / 1 each pattern describes a problem which occurs over and over again in out environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over and over, without ever doing it the same way twice. Christopher Alexander, GoF, p.2 Alexander was an architect who studies ways to improve the process of designing buildings and urban areas.

6 5 / 1 Design Patterns in Software Ways of writing / organizing code to solve specific problems.

7 6 / 1 Each Pattern has Name a concise and meaningful name. Problem what is the problem and context where we would use this pattern? Solution a description of the elements that make up the pattern. Not a concrete design or implementation; rather an abstract description. Consequences the pros and cons of using the pattern.

8 7 / 1 Why we need patterns? Learn from the wisdom of the ages Reuse other people s experience. Establish a shared vocabulary. Make it easier to communicate the design to others. Improve your design process. Naming things shape the way you think about them. Naming things help you discover abstractions and commonalities between situations.

9 8 / 1 Properties of Design Patterns Describes a proven approach to dealing with a common situation in programming / design. Suggest what to do to obtain elegant, modifiable, extensible, flexible & reusable solution. Is independent of a specific language.

10 9 / 1 Patterns vs. Guidelines Guidelines provide general rules of thumb, like: program to an interface, not to an implementation. each class should be responsible for one thing. have low coupling between classes.... Patterns provide concrete solutions often, patterns help you implement the guidelines.

11 10 / 1 Pattern Example Template Method

12 10 / 1 Pattern Example Template Method Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Methods lets subclasses redefine certain steps of an algorithm without changing the algorithm s structure.

13 10 / 1 Pattern Example Template Method Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Methods lets subclasses redefine certain steps of an algorithm without changing the algorithm s structure. We have seen this already!

14 Template Methods Pattern Example public abstract class DiscreteSignalBase { //... public double getvalueat(double x) { if (x < this.firstmeasurementpoint() x > this.lastmeasurementpoint()) { return 0; if (x == this.lastmeasurementpoint()) { return this.yvals[this.xvals.length - 1]; double ans = 0; for (int i = 1; i < this.xvals.length; i++) { double x0 = this.xvals[i - 1]; double x1 = this.xvals[i]; if (x >= x0 && x < x1) { double y0 = this.yvals[i - 1]; double y1 = this.yvals[i]; ans = this.calculatevalueat(x,x0,y0,x1,y1); break; return ans; 11 / 1

15 12 / 1 Template Methods Pattern Example public abstract class DiscreteSignalBase { //... public double getvalueat(double x) { //... ans = this.calculatevalueat(x,x0,y0,x1,y1); //... abstract protected double calculatevalueat( double x, double x0, double y0, double x1, double y1); getvalueat(double x) is a template method! it defines the skeleton of an algorithm, and a certain part of it is redefined in a subclass class.

16 Another Example 13 / 1

17 14 / 1 Consider this collections interface. public interface Collection { boolean isempty(); int size(); void add(comparable o); void remove(comparable o); void addall(collection other); void removeall(collection other); Comparable getsmallest(); Comparable getlargest(); Comparable getithelement(int i); boolean contains(comparable o); boolean containsany(collection other); boolean containsall(collection other);

18 15 / 1 We would like to define the following implementations: A dynamic-size Array Linked List Skip-List Binary Tree

19 15 / 1 We would like to define the following implementations: A dynamic-size Array Linked List Skip-List Binary Tree So much work!

20 public interface Collection { boolean isempty(); int size(); void add(comparable o); void remove(comparable o); void addall(collection other); void removeall(collection other); Comparable getsmallest(); Comparable getlargest(); Comparable getithelement(int i); boolean contains(comparable o); boolean containsany(collection other); boolean containsall(collection other); 16 / 1

21 17 / 1 public interface Collection { boolean isempty(); // derived int size(); void add(comparable o); void remove(comparable o); void addall(collection other); // derived void removeall(collection other); // derived Comparable getsmallest(); // derived Comparable getlargest(); // derived Comparable getithelement(int i); boolean contains(comparable o); // derived? boolean containsany(collection other); // derived boolean containsall(collection other); // derived

22 Perfect for template methods! 18 / 1

23 Perfect for template methods! public abstract class CollectionBase { abstract int size(); abstract void add(comparable o); abstract void remove(comparable o); abstract getithelement(int 0); boolean isempty() { return (this.size() == 0); void addall(collection other) { for (int i = 0; i < other.size(); i++) { this.add(other.getithelement(i));... void removeall(collection other) { for (int i = 0; i < other.size(); i++) { this.remove(other.getithelement(i)); 18 / 1

24 Comparable getlargest() { if (this.isempty()) { return null; Comparable max = this.getithelement(0); for (int i = 1; i < other.size(); i++) { Comparable current = this.getithelement(i); if (current.compareto(max) > 0) { current = max; return max; 19 / 1... Comparable getsmallest() { if (this.isempty()) { return null; Comparable min = this.getithelement(0); for (int i = 1; i < other.size(); i++) { Comparable current = this.getithelement(i); if (current.compareto(min) < 0) { current = min; return min;

25 20 / 1... boolean contains(comparable o) { for (int i = 0; i < this.size(); i++) { if (this.getithelement(i).equals(o)) { return true; return false; boolean containsany(collection other) { for (int i = 0; i < other.size(); i++) { Comparable o = other.getithelement(i); if (this.contains(o)) { return true; return false;...

26 21 / 1... boolean containsall(collection other) { for (int i = 0; i < other.size(); i++) { Comparable o = other.getithelement(i); if (!this.contains(o)) { return false; return true;

27 Implementing a concrete collection: BinaryTree 22 / 1

28 23 / 1 public class BinaryTree extends CollectionBase implements Collection { private Comparable value; private BinaryTree left; private BinaryTree right;... public BinaryTree(Comparable value) { this(value, null, null); public BinaryTree(Comparable v, BinaryTree l, BinaryTree r) { this.value = v; this.left = l; this.right = r; private isleaf() { return (this.left == null && this.right == null);

29 24 / public int size() { ans = 1; if (this.left!= null) { ans += this.left.size(); if (this.right!= null) { ans += this.right.size(); return public void add(comparable c) { if (c.compareto(this.value) < 0) { this.addleft(c); else { this.addright(c);...

30 ... private void addleft(comparable c) { if (this.left == null) { this.left = new BinaryTree(c); else { this.left.add(c); private void addright(comparable c) { public Comparable getithelement(int i) { public void remove(comparable c) { // / 1

31 26 / 1 Template Method Implementing four basic methods in each class. Getting rich collections that use these methods.

32 27 / 1 Design Patterns - benefits of a common vocabulary Instead of saying: We have some shared behavior that is common for all classes, but some operations that are used in these methods are specific for each implementation. So what we did is to create an abstract base class with some abstract methods that are used as place-holders, and we wrote some methods that rely on the abstract methods. Now the deriving class should provide implementation to the abstract methods, and the methods that are using the abstract methods will just work. we can just say: We used the template method pattern

33 Factory Pattern 28 / 1

34 29 / 1 War Cards Game. (Again.)

35 30 / 1 Reminder War Card Game Card Deck Pile Player Dealer WarGameLogic WarGame

36 31 / 1 Requirements Change Different Kinds of Decks A regular Deck (like we already have). A MagiciansDeck with 52 identical cards. Gets the Card value in the constructor. A MessyDeck with 52 random cards (can have duplicates).

37 31 / 1 Requirements Change Different Kinds of Decks A regular Deck (like we already have). A MagiciansDeck with 52 identical cards. Gets the Card value in the constructor. A MessyDeck with 52 random cards (can have duplicates). We know the drill: Make Deck an interface. RegularDeck, MagiciansDeck, MessyDeck all implement Deck. (optional 1): all derive from (extend) Deck (optional 2): all derive from abstract DeckBase

38 31 / 1 Requirements Change Different Kinds of Decks A regular Deck (like we already have). A MagiciansDeck with 52 identical cards. Gets the Card value in the constructor. A MessyDeck with 52 random cards (can have duplicates). We know the drill: Make Deck an interface. RegularDeck, MagiciansDeck, MessyDeck all implement Deck. (optional 1): all derive from (extend) Deck (optional 2): all derive from abstract DeckBase Dealer needs to know which deck to use.

39 31 / 1 Requirements Change Different Kinds of Decks A regular Deck (like we already have). A MagiciansDeck with 52 identical cards. Gets the Card value in the constructor. A MessyDeck with 52 random cards (can have duplicates). We know the drill: Make Deck an interface. RegularDeck, MagiciansDeck, MessyDeck all implement Deck. (optional 1): all derive from (extend) Deck (optional 2): all derive from abstract DeckBase Dealer needs to know which deck to use. pass it on the constructor!

40 32 / 1 Different Kinds of Decks Problem Consider a dealer implementation:

41 32 / 1 Different Kinds of Decks Problem Consider a dealer implementation: public class HalfHalfDealer implements Dealer { public void deal(player p1, Player p2) { Deck deck = new Deck(); deck.shuffle(); // We know that a new deck has 52 cards, an even number. while (!deck.isempty()) { p1.collectcard(deck.taketopcard()); p2.collectcard(deck.taketopcard());

42 Different Kinds of Decks Problem If we move Deck to the constructor: public class HalfHalfDealer implements Dealer { private Deck deck; public HalfHalfDealer(Deck deck) { this.deck = deck; public void deal(player p1, Player p2) { deck.shuffle(); while (!deck.isempty()) { p1.collectcard(deck.taketopcard()); p2.collectcard(deck.taketopcard()); //... public static void main(string[] args) { Deck deck = new MessyDeck(); Dealer dealer = new HalfHalfDealer(deck); dealer.deal(new Player("a"), new Player("b")); dealer.deal(new Player("c"), new Player("d")); 33 / 1

43 Different Kinds of Decks Problem If we move Deck to the constructor: public class HalfHalfDealer implements Dealer { private Deck deck; public HalfHalfDealer(Deck deck) { this.deck = deck; public void deal(player p1, Player p2) { deck.shuffle(); while (!deck.isempty()) { p1.collectcard(deck.taketopcard()); p2.collectcard(deck.taketopcard()); Problem Dealer creates a new Deck in the deal method. the deck is ruined after the dealing is done. We cannot pass the deck on the constructor if we want to run the dealer more than once! 34 / 1

44 35 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

45 35 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Encapsulate the creation behavior in its own interface.

46 35 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Encapsulate the creation behavior in its own interface. public interface DeckFactory { Deck create();

47 36 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

48 36 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Encapsulate the creation behavior in its own interface.

49 36 / 1 Different Kinds of Decks Solution Factory Pattern Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Encapsulate the creation behavior in its own interface. public interface DeckFactory { Deck create();

50 37 / 1 Different Kinds of Decks Solution public interface DeckFactory { Deck create();

51 37 / 1 Different Kinds of Decks Solution public interface DeckFactory { Deck create(); public class HalfHalfDealer implements Dealer { private DeckFactory df; public HalfHalfDealer(DeckFactory df) { this.df = df; public void deal(player p1, Player p2) { Deck deck = this.df.create(); deck.shuffle(); while (!deck.isempty()) { p1.collectcard(deck.taketopcard()); p2.collectcard(deck.taketopcard());

52 Different Kinds of Decks Solution public interface DeckFactory { Deck create(); public class HalfHalfDealer implements Dealer { private DeckFactory df; public HalfHalfDealer(DeckFactory df) { this.df = df; public void deal(player p1, Player p2) { Deck deck = this.df.create(); deck.shuffle(); while (!deck.isempty()) { p1.collectcard(deck.taketopcard()); p2.collectcard(deck.taketopcard()); Dealer is creating Decks, but doesn t know which ones. 37 / 1

53 38 / 1 Using the deck factory public static void main(string[] args) { DeckFactory messyfactory = new MessyDeckFactory(); Dealer dealer = new HalfHalfDealer(messyFactory); dealer.deal(new Player("a"), new Player("b")); dealer.deal(new Player("c"), new Player("d"));

54 39 / 1 Deck Factories public class RegularDeckFactory implements DeckFactory { public Deck create() { return new RegularDeck();

55 39 / 1 Deck Factories public class RegularDeckFactory implements DeckFactory { public Deck create() { return new RegularDeck(); public class MessyDeckFactory implements DeckFactory { public Deck create() { return new MessyDeck();

56 40 / 1 Deck Factories public class RegularDeckFactory implements DeckFactory { public Deck create() { return new RegularDeck(); public class MessyDeckFactory implements DeckFactory { public Deck create() { return new MessyDeck(); What about the MagiciansDeck? Remember, it gets a Card at the constructor.... and the DeckFactory interface defines create() without parameters. what can we do? where do we specify the card?

57 41 / 1 Deck Factories public class MagiciansDeckFactory implements DeckFactory { private Card card; public MagiciansDeckFactory(Card c) { this.card = c; public Deck create() { return new MagiciansDeck(this.card);

58 42 / 1 public static void main(string[] args) { Card c = new Card(12, Card.DIAMONDS); DeckFactory factory = new MagiciansDeckFactory(c); Dealer dealer = new HalfHalfDealer(factory); dealer.deal(new Player("a"), new Player("b")); dealer.deal(new Player("c"), new Player("d"));

59 43 / 1 Factory Pattern Decouple the identity of the created class from the class that creates it. Allows class A creates instances of class B, without knowing B s actual type. (Dealer is creating Decks without knowing the Decks types.) This behavior is achieved through an interface which is responsible for the creation behavior.

60 44 / 1 Observer Pattern (also called Listener, EventListener, Publish-subscribe)

61 45 / 1 War Cards Game. (Again.)

62 46 / 1 Requirements Change Need to Collect Statistics Number of turns without a war. Number of turns with a war. Longest number of wars in single turn. Number of turn-wins for each player.

63 46 / 1 Requirements Change Need to Collect Statistics Number of turns without a war. Number of turns with a war. Longest number of wars in single turn. Number of turn-wins for each player. How would you implement this?

64 46 / 1 Requirements Change Need to Collect Statistics Number of turns without a war. Number of turns with a war. Longest number of wars in single turn. Number of turn-wins for each player. How would you implement this? Need to track the statistics. turns and wars take place inside the WarGameLogic class. Add counting variables and accessors to WarGameLogic?

65 47 / 1 public class WarGameLogic { private CardComparator cardcompare; private int numturns; private int numturnswithwars; private int longestwarsequence; private int currentwarlength; private int numwinsplayer1;... public WarGameLogic(CardComparator cardcompare) { this.cardcompare = cardcompare; this.numturns = 0; this.numturnswithwars = 0; this.longestwarsequence = 0; this.numwinsplayer1 = 0;

66 48 / 1 public Player playoneturn(player p1, Player p2) { this.numturns += 1; // new this.currentwarlength = 0; // new Pile pile = new Pile(); Player winner = this.drawcardsandannouncewinner(p1, p2, pile); winner.collectwinningcards(pile); if (winner == p1) { // new this.numwinsplayer1 += 1; // new return winner; private Player drawcardsandannouncewinner(player p1, Player p2,pile pile){ //......

67 49 / 1 private Player dowar(player p1,player p2,pile pile) { this.currentwarlength += 1; if (this.currentwarlength > this.longestwarsequence){ this.longestwarsequence=this.currentwarlength; for (int i = 0; i < 2; ++i) { Card c = p1.playtopcard(); if (c!= null) { pile.addcard(c); //... public int getplayer1wins() { return this.numwinsplayer1; public int getplayer2wins() { return this.numturns - this.numwinsplayer1; //...

68 50 / 1 Not so nice Remember: Each class should be responsible of one thing This is called high cohesion.

69 50 / 1 Not so nice Remember: Each class should be responsible of one thing This is called high cohesion. The WarGameLogic class is doing too much: Handle Logic Track The Statistics

70 50 / 1 Not so nice Remember: Each class should be responsible of one thing This is called high cohesion. The WarGameLogic class is doing too much: Handle Logic Track The Statistics What do we do if the required statistics change? (we also didn t say how we are going to access the data.)

71 50 / 1 Not so nice Remember: Each class should be responsible of one thing This is called high cohesion. The WarGameLogic class is doing too much: Handle Logic Track The Statistics What do we do if the required statistics change? (we also didn t say how we are going to access the data.) Solution Introduce a new StatisticsTracker class. (StatisticsTracker can (should?) be an interface.)

72 51 / 1 public class StatisticsTracker { private int numturns; private int numturnswithwars; private int longestwarsequence; private int currentwarlength; private int numwinsplayer1;... public StatisticsTracker() { this.numturns = 0; this.numturnswithwars = 0; this.longestwarsequence = 0; this.numwinsplayer1 = 0;

73 52 / 1 public void turnstarted() { this.numturns += 1; this.currentwarlength = 0; public void turnended(int winner) { if (winner == 1) { this.numwinsplayer1 += 1; public void warphase() { this.currentwarlength += 1; if (this.currentwarlength > this.longestwarsequence){ this.longestwarsequence=this.currentwarlength; public int getplayer1wins() { return this.numwinsplayer1; //...

74 public class WarGameLogic { private CardComparator cardcompare; private StatisticsTracker stats; public WarGameLogic(CardComparator cardcompare, StatisticsTracker statstracker) { this.cardcompare = cardcompare; this.stats = statstracker; public Player playoneturn(player p1, Player p2) { this.stats.turnstarted(); Pile pile = new Pile(); Player winner = this.drawcardsandannouncewinner(p1, p2, pile); winner.collectwinningcards(pile); int winnernum = winner == p1? 1 : 2; this.stats.turnended(winnernum); return winner; / 1

75 54 / 1 private Player drawcardsandannouncewinner(player p1, Player p2,pile pile){ //... private Player dowar(player p1,player p2,pile pile) { this.stats.warphase(); for (int i = 0; i < 2; ++i) { Card c = p1.playtopcard(); if (c!= null) { pile.addcard(c); //...

76 55 / 1 Solution So Far: The WarGameLogic class holds a StatisticsTracker. WarGameLogic notifies the StatisticsTracker about game events. The StatisticsTracker class tracks the interesting statistics. Advantages We separated (decoupled) the stats-tracking logic from the game-playing logic. Each class is responsible for one thing. Easy to change/replace the tracked statistics without changing the WarGameLogic code.

77 56 / 1 Requirements Change 2 Want to add a narration to the game Print out the game progression: player 1 wins! we have a war! we have another war! and, we have another war! player 2 wins a turn with 3 wars! player 2 wins! player 2 wins again! player 2 wins again! player 2 wins again! player 2 is on a winning streak! player 2 wins again! player 1 wins!... Where would you add this?

78 57 / 1 Adding a narration Implement it in the WarGame or WarGameLogic? NO. As with the statistics, this will result in low-cohesion: the WarGameLogic will be responsible for two things!

79 57 / 1 Adding a narration Implement it in the WarGame or WarGameLogic? NO. As with the statistics, this will result in low-cohesion: the WarGameLogic will be responsible for two things! Implement a GameNarrator class. Like the StatisticsTracker class, the Narrator will receive notifications on game events from the WarGameLogic, and will choose how to display them. (GameNarrator can be an interface.)

80 public class WarGameLogic { private CardComparator cardcompare; private StatisticsTracker stats; private GameNarrator narrator; public WarGameLogic(CardComparator cardcompare, StatisticsTracker statstracker, GameNarrator narrator) { this.cardcompare = cardcompare; this.stats = statstracker; this.narrator = narrator; public Player playoneturn(player p1, Player p2) { this.stats.turnstarted(); this.narrator.turnstarted(); Pile pile = new Pile(); Player winner = this.drawcardsandannouncewinner(p1, p2, pile); winner.collectwinningcards(pile); int winnernum = winner == p1? 1 : 2; this.stats.turnended(winnernum); this.narrator.turnended(winnernum); return winner; 58 / 1

81 59 / 1 Another Requirement Digests WarGames can be very long. We would like to be able to send short summaries every 50 turns. Hello John, since the last update, player 1 won 29 times and player 2 won 21 times. 18 wars took place.

82 59 / 1 Another Requirement Digests WarGames can be very long. We would like to be able to send short summaries every 50 turns. Hello John, since the last update, player 1 won 29 times and player 2 won 21 times. 18 wars took place. Add an DigestCreator class? Yep, this will work.

83 60 / 1 Problems with the approach High Coupling WarGameLogic needs to know about the existence of: StatisticsTracker GameNarrator DigestCreator Any similar class we may add. We have to change the code of WarGameLogic each time. We have High Coupling between the WarGameLogic and the StatisticsTracker, GameNarrator, DigestCreator classes.

84 60 / 1 Problems with the approach High Coupling WarGameLogic needs to know about the existence of: StatisticsTracker GameNarrator DigestCreator Any similar class we may add. We have to change the code of WarGameLogic each time. We have High Coupling between the WarGameLogic and the StatisticsTracker, GameNarrator, DigestCreator classes. Additionally What if we want only Digest but not GameNarrator? What if we want to send Digests to 5 different users? What if a user want to stop receiving notifications?

85 Enters the Observer pattern. 61 / 1

86 62 / 1 The Observer Pattern The Problem being solved An object needs to: Send updates to many different consumers. The set of consumers can change over time. Consumers can ask to not get any more notifications. The object should not care who the consumers are. The consumers can receive messages from many different objects. Terminology: The object sending the notifications is called the observable or subject. The consumers are called observers.

87 63 / 1 The Observer Pattern The Observed object: (WarGameLogic) Defines a common interface that receivers of notifications should implement. ( GameEventListener ) Adds methods to: Add a new receiver. Remove a receiver. Notify all receivers. The Observer objects: (i.e. GameNarrator) Implement the interface. Register themselves with the Observable.

88 64 / 1 Observer Pattern in the War Game public interface GameEventListener { void turnstarted(); void turnended(int winner); void warphase();

89 Observer Pattern in the War Game public class StatisticsTracker implements GameEventListener { private int numturns; private int numturnswithwars; private int longestwarsequence; private int currentwarlength; private int numwinsplayer1; public StatisticsTracker() { this.numturns = 0; this.numturnswithwars = 0; this.longestwarsequence = 0; this.numwinsplayer1 = 0; public void turnstarted() { this.numturns += 1; this.currentwarlength = 0; // / 1

90 Observer Pattern in the War Game public class WarGameLogic { private CardComparator cardcompare; private List<GameEventListener> listeners; public WarGameLogic(CardComparator cardcompare) { this.cardcompare = cardcompare; this.listeners = new ArrayList<GameEventListener>();... public Player playoneturn(player p1, Player p2) { this.notifyturnstarted(); Pile pile = new Pile(); Player winner = this.drawcardsandannouncewinner(p1, p2, pile); winner.collectwinningcards(pile); int winnernum = winner == p1? 1 : 2; this.notifyturnended(winnernum); return winner; 66 / 1

91 Observer Pattern in the War Game public class WarGameLogic { private CardComparator cardcompare; private List<GameEventListener> listeners; public WarGameLogic(CardComparator cardcompare) { this.cardcompare = cardcompare; this.listeners = new ArrayList<GameEventListener>(); public Player playoneturn(player p1, Player p2) { this.notifyturnstarted(); Pile pile = new Pile(); Player winner = this.drawcardsandannouncewinner(p1, p2, pile); winner.collectwinningcards(pile); int winnernum = winner == p1? 1 : 2; this.notifyturnended(winnernum); return winner; 67 / 1

92 Observer Pattern in the War Game public class WarGameLogic { //... public void addlistener(gameeventlistener lst) { this.listeners.add(lst); public void removelistener(gameeventlistener lst) { this.listeners.remove(lst); public void notifyturnstarted() { for (GameEventListener l : this.listeners) { l.turnstarted(); public void notifyturnended(int winner) { for (GameEventListener l : this.listeners) { l.turnended(winner); // / 1

93 69 / 1 Observer Pattern in the War Game WarGameLogic logic = new WarGameLogic(); GameNarrator narrator = new WarGameNarrator(); StatisticsTracker stats = new StatisticsTracker(); DigestCreator 1 = new DigestCreator("John", "john@doe.com"); DigestCreator 2 = new DigestCreator("Jane","jane@darc.com"); logic.addlistener(narrator); logic.addlistener(stats); logic.addlistener( 1); logic.addlistener( 2); //... run the game

94 70 / 1 The Observer Pattern The observed object (WarGameLogic) send messages to 0 or more observers (listeners). Communication is achieved through a shared interface. The observers (or listeners) register themselves with the observed object. The observed object does not care who the receivers are. He just needs to know that: they showed interest in receiving the messages. they are capable of handling them.

95 71 / 1 The Observer Pattern - Advanced Usage Requirement: A game variant in which, every 10 turns, the card comparison rules change. This behavior should stop after the first war event.

96 71 / 1 The Observer Pattern - Advanced Usage Requirement: A game variant in which, every 10 turns, the card comparison rules change. This behavior should stop after the first war event. This can be implemented using the GameEventListener how?

97 72 / 1 public class ComparisonChangeBehavior implements GameEventListener { private WarGameLogic logic; private int turnscounter; public ComparisonChangeBehavior(WarGameLogic logic) { this.logic = logic; this.turnscounter = 0; this.logic.addlistener(this); public void turnstarted() { this.turnscounter+=1; if (turnscounter == 10) { this.logic.setcardcomparator(...); this.turnscounter = 0; public void warphase() { this.logic.removelistener(this); public void turnended(int winner) {

98 73 / 1 The EventListener can know the object it listens to, and can send messages to it based on events. The EventListener can also ask to be removed from the notification list.

99 74 / 1 Summary Design Patterns Suggested solutions for re-occurring situations in software design and organization. Some Specific Patterns Template Method Factory Observer / Listener