given the description of a problem, how do you determine what classes to define?
DESCRIPTION
Given the description of a problem, how do you determine what classes to define? how do you design each class? Need a design methodology. Object-Oriented Design. Often software mimics the real world Decompose problem into objects identify properties and behaviors model in software - PowerPoint PPT PresentationTRANSCRIPT
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
1. Consider properties of the entity to be modeled
2. Decide which properties relevant- which to actually model
3. Decide how to model properties
7
Stopwatch Properties
1. Properties of real stopwatches– function buttons, display, memory
2. Which relevant?– Say ours will be used to get time between
mouse clicks– no display or buttons needed
3. 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 Gamepublic 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 marblepublic 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 Gamepublic 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 Gamepublic class Cup {
// List of cup properties
// Graphical image of the cupprivate FilledRect cupSide;private FilledOval cupTop, cupBottom;private FramedRect sideFrame;private FramedOval topFrame, bottomFrame;
// Whether the cup contains the marbleprivate 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 marblepublic class Marble {
// Marble properties// Graphical image of the marbleprivate 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 marblepublic class Marble {
// Graphical image of the marbleprivate FilledOval theMarble;
// Move the marble// dx, dy - distance to move in the vertical and horizontal directionspublic 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 Summary1. Identify objects to be modeled2. For each type of object
– list properties– list behaviors
3. Model Properties with inst. variables4. Model behaviors with methods
– Method headers– Don’t forget constructors
5. 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 worldEx. 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 Gamepublic class Shuffle extends ActiveObject {
// Three cups to be shuffledprivate Cup cup1, cup2, cup3;
// Construct a shuffler
// Shuffle the cupspublic 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
42
43
44
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
51
Encapsulation
• notion of taking variables and data structures and wrapping them inside a class definition
Information Hiding
• notion of hiding details of implementation as much as possible
52
Why Important?
• protects variables from being modified inappropriately by other classes
• can present classes to others for use by simply specifying interface
ex. You used objectdraw library without knowing any implementation details!
• can change details of class definition without affecting those using it.
53
Summary
• Design is a process of iterative refinement
• Good comments/documentation useful for the designer and the reader
• Keep in mind notions of encapsulation and information hiding