1. An Introduction to Programming and Object Oriented Design using Java 2 nd Edition. May 2004 Jaime Niño Frederick Hosch Chapter 3: Designing interactive classes.

2. 1May 2004NH-Chapter 3 Objectives ñAfter studying this chapter you should understand the following: ñthe role of responsibilities in the design of an object; ñthe categorization of an object’s responsibilities as knowing responsibilities or doing responsibilities; ñthe difference between local variables and instance variables; ñthe structure of a complete program in Java; ñthe structure of a test system; ñthe purpose of named constants.

3. 2May 2004NH-Chapter 3 Objectives ñAlso, you should be able to: ñanalyze the role a simple object plays in a given problem and list its responsibilities; ñuse Java to specify the features of an object based on its responsibilities; ñuse Java to implement a simple class that has been specified; ñimplement a complete Java program using a simple text- based interface for an object; ñimplement a simple tester for testing a class implementation; ñdefine named constants.

4. 3May 2004NH-Chapter 3 Designing with objects ñTwo questions when we design an OO system : ñwhat are the objects? ñwhat features should these objects have? ñOur Initial goal: learn to design and implement simple objects. ñWe will ssume objects are there for the picking.

5. 4May 2004NH-Chapter 3 Designing with objects ñObjects are designed to support system functionality. ñSystem specification are distributed as responsibilities to objects identified.

6. 5May 2004NH-Chapter 3 Object responsibilities ñThink in terms of ñwhat object must know. ñwhat object must do.

7. 6May 2004NH-Chapter 3 Object responsibilities ñKnowing responsibilities include: ñknowing properties of the entity object is modeling; ñknowing about other objects with which it needs to cooperate.

8. 7May 2004NH-Chapter 3 Object responsibilities ñDoing responsibilities include: ñcomputing particular values; ñperforming actions that modify its state; ñcreating and initializing other objects; ñcontrolling and coordinating the activities of other objects.

9. 8May 2004NH-Chapter 3 From responsibilities to class features ñ“Knowing responsibilities” ñtranslate into data the object must maintain or ñTranslate into queries. ñ “Doing responsibilities” ñtranslate into commands or ñTranslate into queries.

10. 9May 2004NH-Chapter 3 Designing a class ñTo design a class: ñdetermine an object’s responsibilities, ñclassify them as knowing or doing responsibilities.

11. 10May 2004NH-Chapter 3 Example: Design of Nim game ñGame: Players take turns removing sticks from a pile. Each player in turn removes one, two, or three sticks. The player who removes the last stick loses.

12. 11May 2004NH-Chapter 3 Design of Nim game ñTwo objects for the picking: ñPlayer ñPile of sticks ñPile and Player are part of the model of problem. ñModel aspects of game independently of how is presented to a user or how a user interacts with it.

13. 12May 2004NH-Chapter 3 Designing Pile ñPile a very simple object: ñkeeps track of how many sticks remain. ñPile responsibilities: ñknow: ínumber of sticks remaining ñdo: íreduce number of sticks (remove sticks)

14. 13May 2004NH-Chapter 3 Designing Player ñPlayer takes a turn in the game to remove sticks from Pile. ñPlayer responsibilities: ñknow: íthis Player’s name. íhow many sticks this Player removed on his/her most recent turn. ñdo: ítake a turn by removing sticks from the Pile

15. 14May 2004NH-Chapter 3 From knowing responsibilities to queries ñClass: Pile ñqueries: sticksthe number of sticks remaining in this Pile, a non-negative integer

16. 15May 2004NH-Chapter 3 From knowing responsibilities to queries ñClass: Player ñqueries: ñname : this Player’s name, a String ñsticksTaken : number of sticks this Player removed on his/her most recent turn ( 1, 2, or 3).

17. 16May 2004NH-Chapter 3 From doing responsibilities to commands ñClass: Pile ñcommands: remove : reduce number of sticks by specified amount (number)

18. 17May 2004NH-Chapter 3 From doing responsibilities to commands ñClass: Player ñcommands: takeTurnremove 1, 2, or 3 sticks from the specified Pile (pile)

19. 18May 2004NH-Chapter 3 Interaction diagram:Player takes turn

20. 19May 2004NH-Chapter 3 Pile, and Player constructors ñHow are the Player’s name and the initial number of sticks in the Pile determined?  Set these values when objects are created: Constructors. ñConstructors can have parameters: ñPlayer’s name parameter in Player’s constructor. ñInitial number of sticks parameter in Pile constructor.

21. 20May 2004NH-Chapter 3 Pile specifications  nimGame ñClass Pile public class Pile A pile of sticks for playing simple nim. ñConstructors public Pile (int sticks) Create a new Pile, with the specified number of sticks. sticks must be non-negative.

22. 21May 2004NH-Chapter 3 Pile specifications ñQueries public int sticks () Number of sticks remaining in this Pile. ñCommands public void remove (int number) Reduce the number of sticks by the specified amount. number must be non-negative and not greater than the number of sticks remaining.

23. 22May 2004NH-Chapter 3 Player specifications  nimGame ñClass Player public class Player A player in the game simple nim. ñConstructors public Player (String name) Create a new Player with the specified name.

24. 23May 2004NH-Chapter 3 Player specifications ñQueries public String name () The name of this Player. public int sticksTaken () The number of sticks this Player removed on this Player’s most recent turn: 1, 2, or 3.

25. 24May 2004NH-Chapter 3 Player specifications ñCommands public void takeTurn (Pile pile) Remove 1, 2, or 3 sticks from the specified Pile.

26. 25May 2004NH-Chapter 3 Implementing the class Pile  Instance variable sticksLeft is initialized in constructor and value returned by query sticks : ñData maintained by Pile is number remaining sticks. private int sticksLeft;// sticks left in the Pile public Pile (int sticks) { sticksLeft = sticks; } public int sticks () { return sticksLeft; }

27. 26May 2004NH-Chapter 3 Implementing the class Pile  Executing command reduces instance variable sticksLeft by value client supplies in number.  Command remove is specified with an int parameter number, indicating sticks to be removed: public void remove (int number) { … public void remove (int number) sticksLeft = sticksLeft - number; }

28. 27May 2004NH-Chapter 3 Implementing the class Player ñVariables should be initialized in the constructor. ñPlayer needs to know name and number of sticks taken on most recent turn. private String name;// this Player’s name private int sticksTaken;// sticks taken on this Player’s most recent turn public Player (String name) { this.name = name; this.sticksTaken = 0; }

29. 28May 2004NH-Chapter 3 Implementing the class Player ñQueries simply return the values of the instance variables: public String name () { return name; } public int sticksTaken () { return sticksTaken; }

30. 29May 2004NH-Chapter 3 Invoking a method: acting as client ñGeneral form for invoking a command is ñGeneral form for invoking a query: objectReference. queryName(arguments) objectReference. commandName(arguments);

31. 30May 2004NH-Chapter 3 Implementing Player’s takeTurn  takeTurn method must: Zdetermine how many sticks to take; Give Player the move strategy to take 1 stick. Zremove them from the Pile; pile.remove(1);  store the number removed in sticksTaken instance variable. sticksTaken = 1; /** * Remove 1, 2, or 3 sticks from the specified Pile. * The Pile must not be empty. */ public void takeTurn (Pile pile) { …

32. 31May 2004NH-Chapter 3 Implementing Player’s takeTurn /** * Remove 1, 2, or 3 sticks from the specified Pile. * The Pile must not be empty. */ public void takeTurn (Pile pile) { pile.remove(1); sticksTaken = 1; }

33. 32May 2004NH-Chapter 3 Interaction diagram: Player commands a Pile

34. 33May 2004NH-Chapter 3 Parameters v.s. arguments ñArguments are provided in a method invocation by expressions. Thus we could write something like pile.remove(sticksTaken + 1); or even pile.remove(2*sticksTaken+2);

35. 34May 2004NH-Chapter 3 Parameters v.s. arguments  An invocation of move must provide two arguments, an int and a double in that order. ñArguments must match in number, type and order: public void move (int direction, double distance) { … } object.move(90, 2.5);

36. 35May 2004NH-Chapter 3 Commands and queries ñA command invocation is a form of statement. ñA query, which produces a value, is an expression.  If myCounter is a Counter object and i an int, i = myCounter.currentCount(); i = myCounter.currentCount()+10;

37. 36May 2004NH-Chapter 3 Example: Maze game ñPlayer must find his/her way through a set of connected rooms to reach some goal. ñthere will be tricks player must figure out; ñcreatures of various kinds to be defeated along the way.

38. 37May 2004NH-Chapter 3 Example: Maze game ñObjects for the picking: ñplayer, ñmaze denizens, ñrooms.

39. 38May 2004NH-Chapter 3 Designing Explorer ñExplorer responsibilities: ñknow: Zhis/her name Zlocation in the maze Zamount of annoyance done when poking an opponent Zamount of annoyance he/she can endure before being defeated.

40. 39May 2004NH-Chapter 3 Designing Explorer ñResponsibilities into properties ñnamename of the Explorer ñlocationroom in which Explorer is in ñstrengthmeasure of Explorer’s offensive ability ñtolerancemeasure of what it takes to defeat Explorer

41. 40May 2004NH-Chapter 3 Designing Explorer ñType of value for each Explorer’s property:  Name: String  Location: Room  Strength: int  Tolerance: int Explorer String name Room location int strength10 int tolerance100 String Room

42. 41May 2004NH-Chapter 3 Designing Explorer ñExplorer responsibilities: ñdo: Zchange location in the maze (move from room to room) Zfight a maze Denizen ñcommands to to perform these actions.  movechange location ñpokepoke a Denizen

43. 42May 2004NH-Chapter 3 Designing Explorer ñBoth commands will have parameters:  movechange location (new location) ñpokepoke a Denizen (denizen to poke)

44. 43May 2004NH-Chapter 3 Interaction diagram

45. 44May 2004NH-Chapter 3 A constructor for the class Explorer ñNeed constructor for creating Explorer instances. ñDuring creation properties must be initialized. ñRequire values for name, location, strength, and tolerance be provided as argument. ñConstructor for Explorer has four parameters: create new Explorer (name, location, strength, tolerance )

46. 45May 2004NH-Chapter 3 Explorer specification mazeGame Class Explorer public class Explorer A maze game player. Constructors public Explorer (String name, Room location, int strength, int tolerance) Create a new Explorer with specified name, initial location, strength, and tolerance. Annoyance (hit points) required to defeat this Explorer.

47. 46May 2004NH-Chapter 3 Explorer specification Queries public String name () Name of this Explorer. public Room location () Room in which this Explorer is currently located. public int strength () Annoyance (hit points) this Explorer causes when poking an opponent. public int tolerance () Annoyance (hit points) required to defeat this Explorer.

48. 47May 2004NH-Chapter 3 Explorer specification Commands public void move (Room newRoom) Move to the specified Room. public void takeThat (int hitStrength) Receive a poke of the specified number of hit points. public void poke (Denizen opponent) Poke the specified Denizen.

49. 48May 2004NH-Chapter 3 Implementing class Explorer ñExplorer objects have four properties: name, location, strength, and tolerance. ñUse instance variables to store these values: ñThese variables are initialized in the constructor. private String name;// name private Room location;// current location private int strength;// current strength (hit points) private int tolerance;// current tolerance (hit points)

50. 49May 2004NH-Chapter 3 Implementing class Explorer ñQueries return current values of instance variables.  Example: query location returns value stored in location. public Room location () { return location; }

51. 50May 2004NH-Chapter 3 Implementing class Explorer  Implementing method move, argument value is stored in instance variable location : public void move (Room newRoom) { location = newRoom; }

52. 51May 2004NH-Chapter 3 Implementing class Explorer  Method takeThat is similar to Pile method remove. Argument value, hitStrength, is subtracted from instance variable tolerance and stored in tolerance : public void takeThat (int hitStrength) { tolerance = tolerance - hitStrength; }

53. 52May 2004NH-Chapter 3 Implementing class Explorer  Method poke invokes Denizen’s method takeThat: public void poke (Denizen opponent) { opponent.takeThat(strength); }

54. 53May 2004NH-Chapter 3 Local variables in methods  local variable: method variable created as part of method execution; used to hold intermediate results needed during computation.

55. 54May 2004NH-Chapter 3 Local variables in methods  Want to implement RetailItem method netPrice : public double netPrice () The cost of this RetailItem after discount, and including tax. ñAssume that RetailItem includes instance variables, with the obvious meanings: private double basePrice; private double discountRate; private double taxRate;

56. 55May 2004NH-Chapter 3 Local variables in methods public double netPrice () { double discount; double subtotal; double tax; discount = basePrice * discountRate; subtotal = basePrice - discount; tax = subtotal * taxRate; return subtotal + tax; } Local variables

57. 56May 2004NH-Chapter 3 Defined inside a method. Exists while method executes. Must be initialized before used. otherwise, compiler error. Accessed only from the method. Meaningful only during method execution. Contains some intermediate value needed only during execution of method; value is not part of object’s state. Defined outside any method. Exists as long as the object exists. Initialized in a constructor. Accessed from any class method. Has meaningful value during life of object, whether or not object is actively doing something. Represents an object’s property; its value is part of object’s state. Local variablesInstance variables

58. 57May 2004NH-Chapter 3 ñA complete system includes ñmodel ñuser interface. ñExample:  model Rectangle instance displayed on a computer screen; use int to measure dimensions. ñUser interface object: instance of class RectangleViewer, with one command, displayRectangle. Putting together a complete system

59. 58May 2004NH-Chapter 3  displayRectangle: writes Rectangle’s length, width, area, and perimeter to the screen. ñRectangleViewer queries Rectangle for display data. Putting together a complete system

60. 59May 2004NH-Chapter 3 Designing Rectangle ñRectangle know ñWidth ñLength ñRectangle do ñCompute area ñCompute perimeter

61. 60May 2004NH-Chapter 3 Rectangle specifications figures Class Rectangle public class Rectangle Constructors public Rectangle (int length, int width) Create a new Rectangle with the specified length and width. Queries public int length () The length of this Rectangle. public int width () The width of this Rectangle. public int area () The area of this Rectangle. public int perimeter () The perimeter of this Rectangle.

62. 61May 2004NH-Chapter 3 Specifying RectangleViewer public void displayRectangle (Rectangle rectangle) ñWrite the length, width, area, and perimeter of the specified Rectangle to standard output.

63. 62May 2004NH-Chapter 3 System.out.println ñExecuting the method results in its argument being written to the screen. ñSimple way to write output to the display.  Object System.out has a method public void println (String s) Write a line containing the specified String to standard output.

64. 63May 2004NH-Chapter 3 Implementing displayRectangle public void displayRectangle (Rectangle rectangle) { int outputValue; outputValue = rectangle.length(); System.out.println("length: " + outputValue); outputValue = rectangle.width(); System.out.println("width: " + outputValue); outputValue = rectangle.area(); System.out.println("area: " + outputValue); outputValue = rectangle.perimeter(); System.out.println("perimeter: " + outputValue); }

65. 64May 2004NH-Chapter 3 main Method  Need a public class, containing a method main.  main method: top-level method that initiates execution of a system.  Method main is specified as: public static void main (String[] argv)

66. 65May 2004NH-Chapter 3 main Method ñmain used to ñCreate Rectangle and RectangleViewer, ñCommand RectangleViewer to display Rectangle.

67. 66May 2004NH-Chapter 3 Main class /** * A simple system to display a Rectangle’s properties. */ public class RectangleDisplay { // Run the program. public static void main (String[] argv) { Rectangle theModel; RectangleViewer theUserInterface; theModel = new Rectangle(100,50); theUserInterface = new RectangleViewer(); theUserInterface.displayRectangle(theModel); }

68. 67May 2004NH-Chapter 3 The method toString ñUseful to include in model classes a query to return a String representation of an object’s state. ñIn Java, this method is specified by convention as: public String toString () A String representation of the object.

69. 68May 2004NH-Chapter 3 The method toString ñFor example, define the method in the class Rectangle : /** * A String representation of this object. */ public String toString () { return "Rectangle: length = " + length + " width = " + width; }

70. 69May 2004NH-Chapter 3 Testing ñUnit testing: test class being implemented to make sure it behaves as expected. ñFunctional testing: test entire system to ensure that it meets customer’s specifications.

71. 70May 2004NH-Chapter 3 Test driven implementation ñIncremental test-driven implementation: most effective means of reducing time required to track down and correct bugs. ñTest-driven aspects ñThe process is to code a little, test a little. ñ Implementation is “test-driven.”: write test for a feature before implementing the feature.

72. 71May 2004NH-Chapter 3 Test driven implementation example  Stubbed implementation of TrafficSignal Left blank Dummy return value public class TrafficSignal { public static final int GREEN = 0; public static final int YELLOW = 1; public static final int RED = 2; private int light; public TrafficSignal () { } public int light () { return 0; } public void change () { }

73. 72May 2004NH-Chapter 3 TrafficSignalTest class ñTrafficSignalTest ñClient of TrafficSignal ñCreates instance of TrafficSignal ñQueries and commands TrafficSignal instance ñUser interface object, reporting test results to user.

74. 73May 2004NH-Chapter 3 TrafficSignalTest class ñThe only property of a TrafficSignalTest properties ñ TrafficSignal to be tested. ñTrafficSignalTest function is to test the TrafficSignal. ñSpecify a single command for the class: public void runTest () Test a TrafficSignal.

75. 74May 2004NH-Chapter 3 TrafficSignalTest class ñHow does the TrafficSignalTest get a TrafficSignal to test?  TrafficSignal could be an argument, either to TrafficSignalTest constructor or to method runTest ;  TrafficSignal could be created by TrafficSignalTest, either in its constructor or in the method runTest

76. 75May 2004NH-Chapter 3 TrafficSignalTest class class TrafficSignalTest { private TrafficSignal signal; // the object to test //Create a TrafficSignalTest public TrafficSignalTest () { signal = new TrafficSignal(); } // Run the test. public void runTest () { }

77. 76May 2004NH-Chapter 3 The initializing class /** * A simple test system for the class TrafficSignal. */ public class Test { /** * Run a TrafficSignal test. */ public static void main (String[] argv) { TrafficSignalTest test; test = new TrafficSignalTest(); test.runTest(); }

78. 77May 2004NH-Chapter 3 Writing tests ñUse private methods testing each feature of TrafficSignal. ñPlace invocations of these methods in runTest()

79. 78May 2004NH-Chapter 3 testInitialState  May run test, getting misleading correct results; class TrafficSignal has only been stubbed. private void testInitialState () { System.out.println("testInitialState:"); System.out.println( "Initial light: " + signal.light()); } public void runTest () { testInitialState(); }

80. 79May 2004NH-Chapter 3 TrafficSignal constructor and query ñRun the test, getting correct result because we have correctly implemented the constructor and query. ñFor class TrafficSignal need to implement ñTrafficSignal constructor ñQuery light: testInitialState invokes it. public TrafficSignal () { light = TrafficSignal.GREEN; //initial state } public int light () { return light; }

81. 80May 2004NH-Chapter 3 Testing command change  Need to build a test for the command change. ñ give the command at least three times and see light cycle from green back to green.  Put this test in its own method and invoke it from runTest : public void runTest () { testInitialState(); testChange(); }

82. 81May 2004NH-Chapter 3 Testing command change private void testChange () { System.out.println("testChange:"); System.out.println("Starting light: " + signal.light()); signal.change(); System.out.println("After 1 change: " + signal.light()); signal.change(); System.out.println("After 2 changes: " + signal.light()); signal.change(); System.out.println("After 3 changes: " + signal.light()); }

83. 82May 2004NH-Chapter 3 Testing command change ñRecall, change() is stubbed as a do-nothing method. ñRecompiling and running TrafficSignalTest produces: testInitialState: Initial light: 0 testChange: Starting light: 0 After 1 change: 0 After 2 changes: 0 After 3 changes: 0

84. 83May 2004NH-Chapter 3 Implementing command change ñRecompiling and running produces successful test. public void change () { light = (light + 1) % 3; }

85. 84May 2004NH-Chapter 3 TrafficSignal and TrafficSignalTest ñHave simple test system for the class TrafficSignal: ñCan modify existing implementation, ñCan add new tests to system, ñExisting tests will help ensure that additions or modifications don’t break implementation.

86. 85May 2004NH-Chapter 3 Static methods  Methods not dependent on the state of an object.  Defined as static, ñAssociated with the class rather with a class instance.

87. 86May 2004NH-Chapter 3 Static methods ñPredefined class Math methods are all static. ñMath includes a square root function specified as: public static double sqrt (double a) The positive square root of the specified value.

88. 87May 2004NH-Chapter 3 Static method invocation ñA static function is invoked by prefixing the name of the class rather than the name of a class instance.  Diagonal method for Rectangle is written as: public double diagonal () { double a = (double)(length*length + width*width); return Math.sqrt(a); }

89. 88May 2004NH-Chapter 3 Final features ñSpecification static implies that feature is associated with the class not with an instance of the class.  Keyword final means that value to which identifier is bound cannot be changed. ñUse class name when referring to feature: ñClass named constants are defined as static final: public static final int GREEN = 0; light = TrafficSignal.GREEN;

90. 89May 2004NH-Chapter 3 Importing static features ñCan import static features of a class. ñCan import one static features. import static Math.sqrt; import static TrafficSignal.GREEN; ñThis allows imported identifiers to be used without being prefixed with the class name return sqrt(a); light = GREEN;

91. 90May 2004NH-Chapter 3 Importing static features ñCan import static features of a class. ñCan import all static features defined in a class. import static Math.*; import static TrafficSignal.*; ñThis allows imported identifiers to be used without being prefixed with the class name

92. 91May 2004NH-Chapter 3 Summary ñdesigning with objects. ñ ask what should the object know and what should the object do. ñenumerate the “knowing responsibilities” and the “doing responsibilities” of the object.

93. 92May 2004NH-Chapter 3 Summary ñObject responsibilities are determined by the object’s role in supporting the functionality of the system. ñSystem functionality is distributed to the comprising objects by assigning a set of responsibilities to each object.

94. 93May 2004NH-Chapter 3 Summary ñ“Knowing responsibilities” translate to queries when the object is defined. ñ“Doing responsibilities” translate into queries or commands. ñItemizing an object’s responsibilities determines the object’s features and its relationship to other objects that comprise the system.

95. 94May 2004NH-Chapter 3 Summary ñWe developed several examples in which one object acts as client to another. ñClient object was provided with a reference to a server as a method argument. ñClient was then able to use server by invoking its methods.

96. 95May 2004NH-Chapter 3 Summary ñProcessor executes method body associated with command, which generally results in the object changing state. ñA command invocation is a form of statement. ñThe format for invoking a command is object. command (arguments);

97. 96May 2004NH-Chapter 3 Summary ñA query invocation is a form of expression, since it computes and returns value. ñThe format is similar to a command invocation: object.query (arguments)

98. 97May 2004NH-Chapter 3 Summary ñA constructor invocation creates a new object, and returns a reference to the newly created object. ñThe format is new class (arguments)

99. 98May 2004NH-Chapter 3 Summary ñWhen a method with formal parameters is invoked, ñmethod variable is allocated for each formal parameter ñMethod initialized with the argument provided by the client. ñA local variable is another kind of method variable. ñLocal variables are created when a method is invoked ñused to hold intermediate results needed during the computation.

100. 99May 2004NH-Chapter 3 Summary ñMethod variables are different from instance variables. ñInstance variables ñcontain data that is part of the object’s state. ñThey are created when the object is created, ñshould always contain a meaningful value. ñMethod variables ñcreated when a method is invoked, ñcontain values that are used only for a specific computation.

101. 100May 2004NH-Chapter 3 Summary ñDeveloped a simple but complete system containing ña model object ñuser interface object.  To complete program, introduced a class with a single method named main.

102. 101May 2004NH-Chapter 3 Summary ñmain is the method that is executed when the program is run. ñIts only function is to create the initial objects and get the system started.

103. 102May 2004NH-Chapter 3 Summary ñIn example, ñmain creates a model object, ñmain creates user interface object, ñmain “starts” user interface, passing it model as argument.

104. 103May 2004NH-Chapter 3 Summary ñWe concluded with a brief introduction to unit testing. ñTo reduce time spent debugging and improve programmer efficiency, we adopt a test-driven implementation strategy. ñIdea: develop a test for each feature or bit of functionality before implementing the feature or adding the functionality.

105. 104May 2004NH-Chapter 3 Summary ñWe construct a class to be used to test another existing class. ñAn instance of testing class invokes commands and queries of object under test, and displays information about its state. ñBy comparing actual results with expected results we can determine if the object under test behaves correctly.