slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Given the description of a problem, how do you determine what classes to define? PowerPoint Presentation
Download Presentation
Given the description of a problem, how do you determine what classes to define?

Loading in 2 Seconds...

play fullscreen
1 / 53

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


  • 94 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Given the description of a problem, how do you determine what classes to define?' - nadine


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1
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
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

abstraction
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.
a simple stopwatch
A Simple Stopwatch

Consider

  • implementing a simple stopwatch
  • Begin by identifying properties and behaviors to model
properties
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
modeling properties
Modeling Properties
  • Consider properties of the entity to be modeled
  • Decide which properties relevant- which to actually model
  • Decide how to model properties
stopwatch properties
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
behaviors
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
stepping through the process
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
step 1 identify objects to model
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

step 2 list properties and behaviors
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
slide12
// 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

}

slide13
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

slide14
// 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

}

slide15
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
slide16
// 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

}

step 3 model properties with inst vars
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

}

slide18
// 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

}

slide19
// 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
design is a process
Design is a Process
  • Well-defined set of steps guides process
  • Need to be open to modifying early decisions

Second Level ShellGame design

step 4 model behaviors with methods
Step 4:Model Behaviors with Methods
  • First focus on method headers (signatures)
  • Describe interface between entities in our program
slide22
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!

slide23
Don’t forget about constructors!

public Cup( Location upperLeft,

double width, double height,

DrawingCanvas canvas )

making choices
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"
slide25
Marble
  • Need to “Move the Marble”

public void move( double dx, doubly dy )

  • Need to “Place marble in cup”
    • But cup already does this!
slide26
// 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!

slide27
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

refinement
Refinement

Designing software is a process of refinement

  • Begin at highest level of abstraction; fill in details
  • Change earlier design decisions, if necessary
filling in the details
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

slide30
Cup methods
  • move
    • straightforward
    • delegate to components
  • contains
    • easy
  • dropIn and showContents more complex
  • "Cup class method details"
slide31
ShellGame methods
  • begin
    • similar to constructor
    • review instance variables; initialize.
    • specifying a value for a variable is a signal that constant needed

begin()

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

onMousePress

slide33
onMouseDrag
    • determine what selected for drag
    • move it

onMouseDrag

slide34
onMouseRelease
  • onMouseClick
design process summary
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
incremental testing
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
unreal entities
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”)
new shell game design
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
shuffler design steps 1 4
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
slide40
// 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()

}

shuffler design step 5
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

slide45
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

slide46
User interface class
  • can reuse some of previous version
  • Player can’t shuffle cups
    • remove selectedCup
    • remove onMousePress, onMouseDrag
slide47
onMouseEnter
    • causes shuffling to begin
    • only makes sense if marble hidden

New Controller design

filling in the details1
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
slide49
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

writing comments
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
slide51
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
why important
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.
summary
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