1. An Object-Oriented Approach to Programming Logic and Design
Chapter 4
Understanding Structure

2. An Object-Oriented Approach to Programming Logic and Design
Objectives
Describe the role of structure in object-oriented methods
Draw flowcharts
Understand unstructured spaghetti code
Understand the three basic structures of sequence, selection, and loop
Build structured methods
An Object-Oriented Approach to Programming Logic and Design

3. Objectives (continued)
Use a priming read
Understand the need for structure
Recognize structure
Describe two special structures:
case
do until
An Object-Oriented Approach to Programming Logic and Design

4. The Role of Structure in Object-Oriented Methods
Recall that classes can contain non-static instance methods such as
public get: to retrieve the object’s data
public set: to set values for the object’s data
Other public methods: to accomplish tasks using the object’s data
An Object-Oriented Approach to Programming Logic and Design

5. The Role of Structure in Object-Oriented Methods (continued)
An application can also contain static methods
No object exists for these methods, but they may manipulate objects instantiated from prewritten classes
All methods should be structured methods
An Object-Oriented Approach to Programming Logic and Design

6. The Role of Structure in Object-Oriented Methods (continued)
A structured method:
Follows a specific set of rules for logical design
Has a single entry and exit point
An Object-Oriented Approach to Programming Logic and Design

7. An Object-Oriented Approach to Programming Logic and Design
Drawing Flowcharts
Symbols on a flowchart:
Lozenge: racetrack-shaped; marks the beginning or end of a method
Annotation symbol: three-sided box attached to flowchart by a dashed line; provides details for a step
Processing statement: rectangle; contains an action taken
Input/output: parallelogram; denotes data coming in from or going out on a device
An Object-Oriented Approach to Programming Logic and Design

8. Drawing Flowcharts (continued)
An Object-Oriented Approach to Programming Logic and Design

9. Understanding Unstructured Spaghetti Code
Spaghetti code: unstructured code that is confusing and complex due to poor structure
Flowchart of spaghetti code shows crossed flow paths with no clear path from beginning to end
Unstructured code is difficult to read, understand, and modify
An Object-Oriented Approach to Programming Logic and Design

10. Understanding Unstructured Spaghetti Code (continued)
An Object-Oriented Approach to Programming Logic and Design

11. Three Basic Structures of Sequence, Selection, and Loop
Structure – a basic unit of programming logic
All programs are composed of 3 structures:
Sequence
Selection
Loop
An Object-Oriented Approach to Programming Logic and Design

12. Three Basic Structures of Sequence, Selection, and Loop (continued)
Sequence structure: performs one or more actions in sequence, with no branching, skipping, or looping; continues step by step
An Object-Oriented Approach to Programming Logic and Design

13. Three Basic Structures of Sequence, Selection, and Loop (continued)
Selection structure: allows one of two or more alternative paths to be taken
if-then-else when only 2 alternatives
if hours-worked is more than 40 then
calculate overtimePay
else
calculate regularPay
An Object-Oriented Approach to Programming Logic and Design

14. Three Basic Structures of Sequence, Selection, and Loop (continued)
Loop structure: allows repetition or iteration
Asks a question and performs an action if a certain answer is given, then asks the question again.
Also called a while loop or a while-do loop
while testCondition continues to be true,
do someProcess
An Object-Oriented Approach to Programming Logic and Design

15. Building Structured Methods
All logic problems can be solved with only the sequence, selection, and looping structures
Structures can be stacked, one after another
Structures can be nested, one within another
An Object-Oriented Approach to Programming Logic and Design

16. Building Structured Methods
An Object-Oriented Approach to Programming Logic and Design

17. Building Structured Methods (continued)
An Object-Oriented Approach to Programming Logic and Design

18. Building Structured Methods (continued)
Block: group of statements that execute as a single unit
All pseudocode statements inside a block should be indented
Indentation in pseudocode reflects the logic shown graphically in a flowchart
An Object-Oriented Approach to Programming Logic and Design

19. Building Structured Methods (continued)
An Object-Oriented Approach to Programming Logic and Design

20. Building Structured Methods (continued)
endif always matches the most recent if that is not already matched
endwhile always matches with the most recent while that is not already matched
An Object-Oriented Approach to Programming Logic and Design

21. Building Structured Methods (continued)
An Object-Oriented Approach to Programming Logic and Design

22. Building Structured Methods (continued)
Each structure has 1 entry and 1 exit point
Other structures may attach only at an entry or exit point
An Object-Oriented Approach to Programming Logic and Design

23. An Object-Oriented Approach to Programming Logic and Design
Using a Priming Read
Priming read (or priming input): the first read or data input statement that occurs before and outside the loop that handles the rest of the input
Priming read is required to keep a method structured
An Object-Oriented Approach to Programming Logic and Design

24. Using a Priming Read (continued)
An Object-Oriented Approach to Programming Logic and Design

25. Using a Priming Read (continued)
Rules for a structured loop:
You ask a question
If the answer indicates a task is to be performed, do so
After you perform the task, go back to ask the question again
An Object-Oriented Approach to Programming Logic and Design

26. Using a Priming Read (continued)
Example: It’s structured, but doesn’t work!
An Object-Oriented Approach to Programming Logic and Design

27. Using a Priming Read (continued)
Example: It works, but isn’t structured!
An Object-Oriented Approach to Programming Logic and Design

28. Using a Priming Read (continued)
Example: It works, and it’s structured!
An Object-Oriented Approach to Programming Logic and Design

29. Using a Priming Read (continued)
public void numberDoubling()
numeric userNumber
numeric answer
while userNumber not = 0
answer = userNumber * 2
print answer
input userNumber
endwhile
return
An Object-Oriented Approach to Programming Logic and Design

30. Understanding the Reasons for Structure
Why structured methods are better:
Clarity: structured methods are less confusing
Professionalism: it is the expected standard in industry today
Efficiency: today’s programming languages are built expecting structure
Maintenance: easier to modify programs later
Modularity: facilitates reuse of modules
An Object-Oriented Approach to Programming Logic and Design

31. Understanding the Reasons for Structure (continued)
An Object-Oriented Approach to Programming Logic and Design

32. Understanding the Reasons for Structure (continued)
An Object-Oriented Approach to Programming Logic and Design

33. Recognizing Structure
Example: Is this flowchart segment structured?
Yes, it has a loop and a selection within the loop
An Object-Oriented Approach to Programming Logic and Design

34. Recognizing Structure (continued)
Example: Is this flowchart segment structured?
No, it is not constructed from the 3 basic structures
An Object-Oriented Approach to Programming Logic and Design

35. Recognizing Structure (continued)
To untangle spaghetti code, pull one “strand” at a time and follow it
Let’s “untangle” this
flowchart 
An Object-Oriented Approach to Programming Logic and Design

36. Recognizing Structure (continued)
Untangling Example: Steps 1 & 2
An Object-Oriented Approach to Programming Logic and Design

37. Recognizing Structure (continued)
Untangling Example: Step 3 – the “No” side of Question B
An Object-Oriented Approach to Programming Logic and Design

38. Recognizing Structure (continued)
Untangling Example: Step 4 – the “Yes” side of Question B
An Object-Oriented Approach to Programming Logic and Design

39. Recognizing Structure (continued)
Untangling Example: Step 5 – left side of Question D: repeat step C to untangle it
An Object-Oriented Approach to Programming Logic and Design

40. Recognizing Structure (continued)
Untangling Example: Step 6 – right side of Question D leads to the end
An Object-Oriented Approach to Programming Logic and Design

41. Recognizing Structure (continued)
An Object-Oriented Approach to Programming Logic and Design

42. Describing Two Special Structures: case and do until
case structure: allows more than 2 alternative paths
do until loop: an alternative to the while loop
case and do until are not needed, but are convenient, acceptable structures
An Object-Oriented Approach to Programming Logic and Design

43. An Object-Oriented Approach to Programming Logic and Design
The case Structure
Use a case when there are several distinct values for a variable, each of which requires a different action
case eliminates the need for a set of nested if statements
An Object-Oriented Approach to Programming Logic and Design

44. The case Structure (continued)
Example: using nested if statements
An Object-Oriented Approach to Programming Logic and Design

45. The case Structure (continued)
Example: using a case statement instead
An Object-Oriented Approach to Programming Logic and Design

46. An Object-Oriented Approach to Programming Logic and Design
The do until Loop
do until loop is similar to the while loop, but tests the condition at the end of the loop
while loop tests the condition at the beginning of the loop; If the answer is no, the action is not performed
do until loop performs the action, then tests the condition; the action is always performed at least once
An Object-Oriented Approach to Programming Logic and Design

47. The do until Loop (continued)
An Object-Oriented Approach to Programming Logic and Design

48. The do until Loop (continued)
while loop pseudocode:
pay bills
while there are more bills to pay
endwhile
do until loop pseudocode: do
until all bills are paid
An Object-Oriented Approach to Programming Logic and Design

49. The do until Loop (continued)
Comparison: using a do until loop
An Object-Oriented Approach to Programming Logic and Design

50. The do until Loop (continued)
Comparison: using a while loop
An Object-Oriented Approach to Programming Logic and Design

51. An Object-Oriented Approach to Programming Logic and Design
Summary
Flowchart symbols:
Lozenge = method header and return
3-sided box = Annotation symbol
Rectangle = statement
Parallelogram = input/output action
Spaghetti code is unstructured, hard to read and modify
Structured code uses 3 basic structures: sequence, selection, and loop
An Object-Oriented Approach to Programming Logic and Design

52. An Object-Oriented Approach to Programming Logic and Design
Summary (continued)
Structures can be stacked and nested
Priming read – the first read or data input prior to beginning a loop
Structured techniques result in clarity, professionalism, efficiency, and modularity
if-then-else handles 2 path choices
case structure handles 2 or more path choices
An Object-Oriented Approach to Programming Logic and Design

53. An Object-Oriented Approach to Programming Logic and Design
Summary (continued)
while loop tests the condition first, then does the action; the action may be performed 0 or more times
do until loop does the action, then tests the condition; it always performs the action at least once
An Object-Oriented Approach to Programming Logic and Design