Given the description of a problem, how do you determine what classes to define?

1. Given the description of a problem, • how do you determine what classes to define? • how do you design each class? • Need a design methodology

2. Object-Oriented Design • Often software mimics the real world • Decompose problem into objects • identify properties and behaviors • model in software Ex.) FallingBall active objects behave like falling balls

3. Abstraction • An object provides an abstraction • can use without knowing details of its implementation • abstract away details; understand at higher level • Follows from our use of objects in real world • can use a stopwatch without knowing exactly how it works • Well-designed classes provide good abstractions.

4. A Simple Stopwatch Consider • implementing a simple stopwatch • Begin by identifying properties and behaviors to model

5. Properties Properties of an object are the nouns and adjectives that describe it • Consider properties of a stopwatch; has • buttons that control functionality • display area • internal memory to store timing info

6. Modeling Properties • Consider properties of the entity to be modeled • Decide which properties relevant- which to actually model • Decide how to model properties

7. Stopwatch Properties • Properties of real stopwatches • function buttons, display, memory • Which relevant? • Say ours will be used to get time between mouse clicks • no display or buttons needed • How to model? • need to calculate elapsed time • need to model start time for calculation

8. Behaviors The verbs that describe object functionality • Behaviors of a real stopwatch • reset to zero • report elapsed time • stop • resume timing • Need to choose which to model

9. Stepping Through the Process Design and implement simple shell game • three cups + 1 marble • player 1 hides marble: drags marble onto a cup • player 1 shuffles cups: drags cups with mouse • player 2 guesses: clicks on a cup • cup raised • marble displayed, if there

10. Step 1:Identify Objects to Model • Objects in problem description • players • cups • marble • Which to model? • cups • marble Note: players are users of program; provide them interface

11. Step 2:List Properties and Behaviors Cup • Properties • image on screen • empty or not • Behaviors • can be moved • can have marble placed in it • can be raised to reveal contents

12. // A class to represent a cup used in the Shell Game public class Cup { // List of cup properties // Graphical image of the cup // Whether the cup contains the marble // List of cup behaviors // Move the cup // Place a marble in the cup // Reveal the contents of the cup; remove marble from cup, // if there }

13. Marble • Properties • image on screen • in a cup or not* • Behaviors • can be moved • can be dropped into cup • can be removed from cup * will ignore this- already modeling containment in cup

14. // A class to represent a marble public class Marble { // List of marble properties // Graphical image of the marble // List of marble behaviors // Move the marble // Place the marble in a cup // Remove the marble from a cup }

15. Need user interface- controller class • Properties • Physical appearance • State of the game • Behaviors • set up game • let user move cup or marble • let user show cup contents

16. // Controller class for a simple Shell Game public class ShellGame extends WindowController { // Properties that describe the shell game // Three cups // A marble // The current position of the mouse // Whether a marble or cup has been selected // Which object has been selected // Allowable game behaviors // Place three cups and a marble on the canvas // Move a cup or marble // Show contents of a cup }

17. Step 3:Model Properties with Inst. Vars. // A class to represent a cup used in the Shell Game public class Cup { // List of cup properties // Graphical image of the cup private FilledRect cupSide; private FilledOval cupTop, cupBottom; private FramedRect sideFrame; private FramedOval topFrame, bottomFrame; // Whether the cup contains the marble private boolean containsMarble; // List of cup behaviors // Move the cup // Place a marble in the cup // Reveal the contents of the cup; remove marble from cup, if there }

18. // A class to represent a marble public class Marble { // Marble properties // Graphical image of the marble private FilledOval theMarble; // Marble behaviors // Move the marble // Place the marble in a cup // Remove the marble from a cup }

19. // Properties that describe the shell game // Three cups // A marble // The current position of the mouse // Whether a marble or cup has been selected // Which object has been selected • On second thought: don’t really need current mouse location. Can get in onMousePress, etc, as needed. • But need last mouse position for dragging

20. Design is a Process • Well-defined set of steps guides process • Need to be open to modifying early decisions Second Level ShellGame design

21. Step 4:Model Behaviors with Methods • First focus on method headers (signatures) • Describe interface between entities in our program

22. Cup • Need to “Move the cup” public void move( double dx, double dy ) • “Place a marble in the cup” public void dropIn( Marble aMarble ) • “Reveal the contents” public void showContents() Note: can’t reveal marble if no ref. to it in the class. Need to add instance variable!

23. Don’t forget about constructors! public Cup( Location upperLeft, double width, double height, DrawingCanvas canvas )

24. Making Choices • Often need to think hard about design choices • Ex. Define cup width and height in Cup class? Controller? • "Third level design: Cup class"

25. Marble • Need to “Move the Marble” public void move( double dx, doubly dy ) • Need to “Place marble in cup” • But cup already does this!

26. // A class to represent a marble public class Marble { // Graphical image of the marble private FilledOval theMarble; // Move the marble // dx, dy - distance to move in the vertical and horizontal directions public void move( double dx, double dy ) } Marble class so far: Nothing but a FilledOval that moves! Class is unnecessary!

27. ShellGame controller • Need to “set up” public void begin() • “Select marble or cup” public void onMousePress( Location mousePos) • a problem: how to determine if mouse in a cup? • add contains method to Cup Third Level for ShellGameClass

28. Refinement Designing software is a process of refinement • Begin at highest level of abstraction; fill in details • Change earlier design decisions, if necessary

29. Filling in the Details • If method simple, write method body • If method complex • outline method body • fill in details of outline • Constructor • useful to consider each instance variable • determine instance variable initialization Cup instance variables and constructor

30. Cup methods • move • straightforward • delegate to components • contains • easy • dropIn and showContents more complex • "Cup class method details"

31. ShellGame methods • begin • similar to constructor • review instance variables; initialize. • specifying a value for a variable is a signal that constant needed begin()

32. onMousePress • check whether mouse in a cup; then check marble • why check cups first? onMousePress

33. onMouseDrag • determine what selected for drag • move it onMouseDrag

34. onMouseRelease • onMouseClick

35. Design Process Summary • Identify objects to be modeled • For each type of object • list properties • list behaviors • Model Properties with inst. variables • Model behaviors with methods • Method headers • Don’t forget constructors • Implementation details • if method simple, write it • if complex, outline first

36. Incremental Testing • Test and debug individual components as they are developed • Finding bugs easier if testing smaller/simpler code • can rely on behavior of smaller entities when testing/debugging larger components

37. Unreal Entities • Not all program classes model entities in the real world Ex. Animated Shell Game • Player places marble in cup as before • Computer shuffles cups (when player moves mouse off canvas and back again) • Player clicks on cup to reveal contents • Program entities • cups, marble (Real) • Shuffle animation (Not so “real”)

38. New Shell Game Design • Marble - FilledOval as before • Cups • identical properties to earlier version • nearly identical behaviors • additional behaviors needed: • ability to move to specific location • ability to report location • ability to be lowered (after being raised to reveal contents) • Additional marble methods

39. Shuffler Design Steps 1-4 *Will need to extend ActiveObject for animation • Identify properties and behaviors (instance variables and methods) • Behaviors • perform shuffling animation (run method) • Properties • harder to identify • not modeling a “real-world” cup shuffler • consider instance variables needed • 3 cups • possibly more later

40. // A class to animate shuffling in a Shell Game public class Shuffle extends ActiveObject { // Three cups to be shuffled private Cup cup1, cup2, cup3; // Construct a shuffler // Shuffle the cups public void run() }

41. Shuffler Design Step 5 Refine ideas for animation • Select two cups *Need RandomIntGenerator • Swap selected cups • can’t simply swap locations • swap must be visible to player • Move 1st cup to temp location • Move 2nd cup to 1st cup’s original spot • Move 1st cup to 2nd cup’s original spot *Note: need instance variable for temp location

45. Constructor • will need to be passed 3 cups • needs to set up temp location (choose to pass in as parameter) • needs to construct RandomIntGenerator for shuffling • needs to start animation Shuffler class design

46. User interface class • can reuse some of previous version • Player can’t shuffle cups • remove selectedCup • remove onMousePress, onMouseDrag

47. onMouseEnter • causes shuffling to begin • only makes sense if marble hidden New Controller design

48. Filling in the Details • Easy • follow comments that outlined our ideas • comments continue to serve as documentation • Let’s only consider Shuffler here • Constructor • remember parameters with instance variables • start animation shuffler Constructor • run method • a bit more interesting

49. run method • select 2 different cups to swap • clever idea: pick the 1 cup that won’t be moved! • perform the swap • pause between moves to make swap visible Implementation of shuffling

50. Writing Comments • Each class should have a class comment • Description of class • Author’s name and date • Each constant and variable should be commented • describe purpose (what, not how!) • parameters • return value, if any • For long/complex methods • include comments in method • explain what is happening • balance clarity and brevity