1. An Introduction to Programming and Object Oriented Design using Java 2 nd Edition. May 2004 Jaime Niño Frederick Hosch Chapter 8: Putting a System Together.

2. 1May 2004NH-Chapter 8 Objectives ñAfter studying this chapter, you should understand the following: ñphases of the software life cycle; ñiterative and compositional nature of the software life cycle; ñfunctional specification of a system; ñidentifying classes, their responsibilities, and relationships among the classes, as fundamental system activities.

3. 2May 2004NH-Chapter 8 Objectives ñAlso, you should be able to: ñdifferentiate between system design and algorithm design; ñidentify potential classes, their responsibilities, and relationships, for a simple problem; ñdraw a static diagram of the design of a simple system; ñimplement a simple system.

4. 3May 2004NH-Chapter 8 Software Life cycle ñThe software life cycle involves ñanalysis; ñspecification; ñdesign; ñimplementation; ñtesting; ñmaintenance.

5. 4May 2004NH-Chapter 8 Software Life cycle ñThe process is ñiterative; ñincremental; ñcompositional.

6. 5May 2004NH-Chapter 8 Design of a System ñGame of “simple nim”: there are two players and a pile of sticks. Each player, in turn, removes one, two, or three sticks from the pile. The player who removes the last stick loses. ñInitial implementation games will be played “computer vs. computer.” ñUser determines whether to play another game and how many sticks to start with.

7. 6May 2004NH-Chapter 8 Functional specification ñBasic function of the system: Play a number of games of “simple nim,” reporting the results to the user.

8. 7May 2004NH-Chapter 8 Functional specification ñSystem functionality: ñAllow user to specify number of sticks at start of game. ñFor each player in turn, determine what play to make (number of sticks to remove) and make the play. ñDisplay state of game after each play: ñnumber of sticks taken, ñnumber of sticks left, ñwhen game is over, who won. ñAllow user to choose to play another game.

9. 8May 2004NH-Chapter 8 Functional specification ñEntering 2 terminates the program. ñEntering 1 produces the following prompt: ñUser interface ñWhen the program is run, the user is offered the following menu: Enter the number denoting the action to perform: Run game...............1 Exit...................2 Enter choice: Enter number of sticks (a positive integer):

10. 9May 2004NH-Chapter 8 Functional specification ñThe original menu is again displayed. ñUser interface ñA play by play description of game is displayed, similar to the following: Player Player1 takes 1 stick(s), leaving 4. Player Player2 takes 3 stick(s), leaving 1. Player Player1 takes 1 stick(s), leaving 0. Player Player2 wins.

11. 10May 2004NH-Chapter 8 System design ñNeed a model and user-interface components. ñNo data component required.

12. 11May 2004NH-Chapter 8 System design ñIdentifying model objects ñTwo players modeled by class Player. ñPile of sticks modeled by class Pile ñGame, (rules of the game), modeled by class Game.

13. 12May 2004NH-Chapter 8 System Design Responsibilities: do: remove sticks know: number of sticks remaining in the Pile Collaborators Class: Pile a pile of sticks for playing simple nim

14. 13May 2004NH-Chapter 8 System Design Responsibilities: do: make a play by removing sticks from the Pile know: Player’s name the number of sticks removed on this Player’s most recent turn Collaborators Pile Class: Player a player of the simple nim game

15. 14May 2004NH-Chapter 8 System Design Responsibilities: do: conduct a play of game, instructing appropriate Player to take a turn know: the Players the Pile number of sticks that can be taken on a turn which Player plays next which Player played last when the game is over which Player won when game is over Collaborators Players, Pile Class: Game a manager of a simple nim game

16. 15May 2004NH-Chapter 8 System Design Responsibilities: do: allow user to indicate whether or not another game is to be played allow user to specify number of sticks to be used in a game have a game played display each play of a game, when the game is over, and which player has won Collaborators Game Game, Player(s) Class: NimTUI text-based user interface for the simple nim system

17. 16May 2004NH-Chapter 8 Relationship between objects

18. 17May 2004NH-Chapter 8 Case: game not over, player1 turn.

19. 18May 2004NH-Chapter 8 Pile specifications class Pile A pile of sticks for playing simple nim public Pile (int sticks) Create a new Pile, with the specified number of sticks. require: sticks >= 0 public int sticks () The number of sticks remaining in this Pile. ensure: this.sticks() >= 0 public void remove (int number) Reduce the number of sticks by the specified amount. require: number >= 0 and number <= this.sticks() ensure: this.sticks() == old.sticks() - number.

20. 19May 2004NH-Chapter 8 Player specifications class Player A player in the game simple nim. public Player (String name) Create a new Player with the specified name. ensure: this.name().equals(name) public String name () This Player’s name. public int sticksTaken () Number of sticks removed on this Player's most recent turn. Returns 0 if this Player has not yet taken a turn. ensure: this.sticksTaken() >= 0.

21. 20May 2004NH-Chapter 8 Game specifications class Game A game manager in the game simple nim. public Game (Player player1, Player player2, int sticks) Create a nim Game, with specified Players and specified number of sticks. First Player specified ( player1 ) plays first in game. require: sticks > 0.

22. 21May 2004NH-Chapter 8 Game specifications public int sticksLeft () The number of sticks remaining in the pile. ensure: this.sticksLeft() >= 0 public Player nextPlayer () The Player whose turn is next. public Player previousPlayer () The Player who last played; returns null if no play has been made yet. public boolean gameOver () The game is over. public Player winner () winning Player: did not make last play in game. Returns null if game is not over. ensure: if this.gameOver(), this.winner() != this.previousPlayer() public void play () Conduct a play of the game, allowing the appropriate Player to take a turn. Has no effect if the game is over.

23. 22May 2004NH-Chapter 8 User interface specifications ñUser ser interface is a client of the Game and the Players. ñGive user interface creation responsibility for Game, as several games might be played. ñGive user interface creation responsibility for Players since we might want to let user name the Players.

24. 23May 2004NH-Chapter 8 User interface specifications class NimTUI A simple text-based user interface for the simple nim system. public NimTUI () Create a new user interface. public void start () Start the interface.

25. 24May 2004NH-Chapter 8 Initializing class ñThe initiating class will look like this: public class NimGame { public static void main (String[] argv) { (new NimTUI()).start(); } }

26. 25May 2004NH-Chapter 8 Creation responsibilities

27. 26May 2004NH-Chapter 8 Implementing class Pile class Pile { private int sticks; public Pile (int sticks) { this.sticks = sticks; } public int sticks () { return sticks; } public void remove (int number) { assert number <= sticks : "precondition: number <= this.sticks()"; sticks = sticks - number; } public String toString () { return "Pile: " + sticks + " sticks."; }

28. 27May 2004NH-Chapter 8 Test-driven implementation of Player ñStubbed implementation of Player. class Player { public Player (String name) { } public String name () { return null; } public int sticksTaken () { return 0; } public void takeTurn (Pile pile, int maxOnATurn) { }

29. 28May 2004NH-Chapter 8 Test-driven implementation of Player ñTest initial state of the Player. private void testInitialState () { setUp(); verify(player.name().equals("Player"), "name set initially"); verify(player.sticksTaken() == 0, "sticksTaken initially 0"); } private void setUp () { player = new Player("Player"); }

30. 29May 2004NH-Chapter 8 Test-driven implementation of Player  To satisfy initial state test, implement queries name, sticksTaken and constructor. private String name; private int sticksTaken; public Player (String name) { this.name = name; this.sticksTaken = 0; } public String name () { return name; } public int sticksTaken () { return sticksTaken; }

31. 30May 2004NH-Chapter 8 Testing method takeTurn  Method requires two arguments, a Pile and maxOnATurn. ñCases to consider testing:  maxOnATurn is smaller than number of sticks in Pile;  maxOnATurn is equal to the number of sticks in Pile;  maxOnATurn is larger than number of sticks in Pile.  Test boundaries of Pile size and maxOnATurn.

32. 31May 2004NH-Chapter 8 Testing method takeTurn ñwe’ll test the following cases: Pile sizemaxOnATurn 533 23 13 511

33. 32May 2004NH-Chapter 8 Testing method takeTurn ñInclude four Piles in the test fixture: private Player player; private Pile pile5;// Pile with 5 sticks private Pile pile3;// Pile with 3 sticks private Pile pile2;// Pile with 2 sticks private Pile pile1;// Pile with 1 stick private void setUp () { player = new Player("Player"); pile5 = new Pile(5); pile3 = new Pile(3); pile2 = new Pile(2); pile1 = new Pile(1); }

34. 33May 2004NH-Chapter 8 Testing method takeTurn /** * Test the takeTurn method with maxOnATurn 1. */ private void testTakeTurnMax1 () { player.takeTurn(pile5,1); verify(pile5.sticks() == 4, "takeTurn size 5, max 1"); verify(player.sticksTaken() == 1, "sticksTaken size 5, max 1"); player.takeTurn(pile1,1); verify(pile1.sticks() == 0, "takeTurn size 1, max 1"); verify(player.sticksTaken() == 1, "sticksTaken size 1, max 1"); }

35. 34May 2004NH-Chapter 8 Testing method takeTurn /** * Test the takeTurn method with maxOnATurn 3. */ private void testTakeTurnMax3 () { player.takeTurn(pile5,3); verify(1 <= player.sticksTaken() && player.sticksTaken() <= 3,"sticksTaken size 5, max 3"); verify(pile5.sticks() == 5 - player.sticksTaken(), "takeTurn size 5, max 3"); player.takeTurn(pile3,3); verify(1 <= player.sticksTaken() && player.sticksTaken() <= 3, "sticksTaken size 3, max 3"); verify(pile3.sticks() == 3 - player.sticksTaken(), "takeTurn size 3, max 3"); player.takeTurn(pile2,3); verify(1 <= player.sticksTaken() && player.sticksTaken() <= 2, "sticksTaken size 2, max 3"); verify(pile2.sticks() == 2 - player.sticksTaken(), "takeTurn size 2, max 3"); player.takeTurn(pile1,3); verify(player.sticksTaken() == 1,"sticksTaken size 1, max 3"); verify(pile1.sticks()== 0, "takeTurn size 1, max 3"); }

36. 35May 2004NH-Chapter 8 Testing method takeTurn ñSimplest implementation of the method : always remove one stick from the Pile. public void takeTurn (Pile pile, int maxOnATurn) { pile.remove(1); sticksTaken = 1; }

37. 36May 2004NH-Chapter 8 Implementing class Game  Implementation easily follows from the specs: class Game { private static final int MAX_ON_A_TURN = 3; private Player player1; private Player player2; private Player nextPlayer; private Player previousPlayer; private Pile pile;

38. 37May 2004NH-Chapter 8 Implementing class Game public Game (Player player1, Player player2, int sticks) { assert sticks > 0 : "precondition: initial sticks > 0"; this.player1 = player1; this.player2 = player2; this.nextPlayer = player1; this.previousPlayer = null; this.pile = new Pile(sticks); }

39. 38May 2004NH-Chapter 8 Implementing class Game public int sticksLeft () { return pile.sticks(); } public Player nextPlayer () { return nextPlayer; } public Player previousPlayer () { return previousPlayer; } public boolean gameOver () { return pile.sticks() == 0; } public Player winner () { if (gameOver()) return otherPlayer(previousPlayer); else return null; }

40. 39May 2004NH-Chapter 8 Implementing class Game public void play () { if (!gameOver()) { nextPlayer.takeTurn(pile,MAX_ON_A_TURN); previousPlayer = nextPlayer; nextPlayer = otherPlayer(nextPlayer); } public String toString () { return "Game with players: " + player1 + ", and “ + player2; } private Player otherPlayer (Player player) { if (player == player1) return player2; else return player1; } }//end of Game implementation

41. 40May 2004NH-Chapter 8 Implementing the TUI ñThe implementation is similar to those seen in chapter 7. ñThe actual implementation is shown in the textbook in chapter 8.

42. 41May 2004NH-Chapter 8 Summary ñPut together a complete, simple system. ñConsidered the life cycle of a system: ñproblem analysis, ñspecification, ñdesign, ñimplementation, ñtesting, and ñmaintenance.

43. 42May 2004NH-Chapter 8 Summary ñLifecycle: Not a series of sequential steps. ñProcess is ñiterative, ñincremental, ñcompositional.

44. 43May 2004NH-Chapter 8 Summary ñDesigned and implemented a system to play the simple nim game. ñSystem design involved ñidentifying classes, ñassigning responsibilities to the classes, ñdetermining fundamental relationships between classes, ñ writing detailed class specifications.

45. 44May 2004NH-Chapter 8 Summary ñDuring implementation noticed that the it was quite straightforward given the system specification. ñImplementing the Player class gave us an opportunity to see another example of test-driven design. ñThe user interface we built was a simple, text-based interface, similar to what we’ve seen before.