Lecture Outline
4.1 Introduction
4.2 Algorithms
4.3 Pseudocode
4.4 Control Structures
4.5 if Single-Selection Statement
4.6 if else Selection Statement
4.7 while Repetition Statement
4.8 Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition)
4.9 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)
4.10 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)
4.11 Compound Assignment Operators
4.12 Increment and Decrement Operators
4.1 Introduction
• We learn about Control Structures
– Structured-programming principle
– Control structures help build and manipulate objects
4.2 Algorithms
• Algorithm
– Series of actions in specific order
• The actions executed
• The order in which actions execute
• Program control
– Specifying the order in which actions execute
• Control structures help specify this order
4.3 Pseudocode
• Pseudocode
– Informal language for developing algorithms
– Not executed on computers
– Helps developers “think out” algorithms
4.4 Control Structures
• Sequential execution
– Program statements execute one after the other
• Transfer of control
– Three control statements can specify order of statements
• Sequence structure
• Selection structure
• Repetition structure
• Activity diagram
– Models the workflow
• Action-state symbols
• Transition arrows
4.4 Control Structures
•Java has a sequence structure “built-in”
• Java provides three selection structures
– if
– If…else
– switch
• Java provides three repetition structures
– while
– do…while
– do
• Each of these words is a Java keyword
4.5 if Single-Selection Statement
•Single-entry/single-exit control structure
• Perform action only when condition is true
• Action & decision according to the chosen programming model
4.6 if…else Selection Statement
• Perform action only when condition is true
• Perform different specified action when condition is false
• Conditional operator (?:)•Nested if…else selection structures
4.7 while Repetition Statement
• Repeat action while condition remains true4.8 Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition)
• Counter
– Variable that controls number of times set of statements executes
• Average1.java calculates grade averages
– uses counters to control repetition
Set total to zero
Set grade counter to one
Input the next grade
Add the grade into the total
Add one to the grade counter
Print the class average
Pseudocode algorithm that uses counter-controlled repetition to solve the class-average problem.
1 // Fig. 4.7: Average1.java
2 // Class-average program with counter-controlled repetition.
3 import javax.swing.JOptionPane;
4
5 public class Average1 {
6
7 public static void main( String args[] )
8 {
9 int total; // sum of grades input by user
10 int gradeCounter; // number of grade to be entered next
11 int grade; // grade value
12 int average; // average of grades
13
14 String gradeString; // grade typed by user
15
16 // initialization phase
17 total = 0; // initialize total
18 gradeCounter = 1; // initialize loop counter
19
20 // processing phase
21 while ( gradeCounter <= 10 ) { // loop 10 times
22
23 // prompt for input and read grade from user
24 gradeString = JOptionPane.showInputDialog("Enter integer grade: " );
25
26
27 // convert gradeString to int
28 grade = Integer.parseInt( gradeString );
29
30 total = total + grade; // add grade to total
31 gradeCounter = gradeCounter + 1; // increment counter
32
33 } // end while
34
35 // termination phase
36 average = total / 10; // integer division
37
38 // display average of exam grades
39 JOptionPane.showMessageDialog( null, "Class average is " + average,
40 "Class Average", JOptionPane.INFORMATION_MESSAGE );
41
42 System.exit( 0 ); // terminate the program
43
44 } // end main
45
46 } // end class Average1
4.9 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)
• Sentinel value
– Used to indicated the end of data entry
• Average2.java has indefinite repetition
– User enters sentinel value (-1) to end repetition
Initialize total to zero
Initialize counter to zero
Input the first grade (possibly the sentinel)While the user has not as yet entered the sentinel
Add this grade into the running total
Add one to the grade counter
Input the next grade (possibly the sentinel)If the counter is not equal to zero
Set the average to the total divided by the counter
Print the average
else
Print “No grades were entered”Fig. 4.8 Class-average problem pseudocode algorithm with sentinel-controlled repetition.
1 // Fig. 4.9: Average2.java
2 // Class-average program with sentinel-controlled repetition.
3 import java.text.DecimalFormat; // class to format numbers
4 import javax.swing.JOptionPane;
5
6 public class Average2 {
7
8 public static void main( String args[] )
9 {
10 int total; // sum of grades
11 int gradeCounter; // number of grades entered
12 int grade; // grade value
13
14 double average; // number with decimal point for average
15
16 String gradeString; // grade typed by user
17
18 // initialization phase
19 total = 0; // initialize total
20 gradeCounter = 0; // initialize loop counter
21
22 // processing phase
23 // get first grade from user
24 gradeString = JOptionPane.showInputDialog("Enter Integer Grade or -1 to Quit:" );
25
26
27 // convert gradeString to int
28 grade = Integer.parseInt( gradeString );
29
30 // loop until sentinel value read from user
31 while ( grade != -1 ) {
32 total = total + grade; // add grade to total
33 gradeCounter = gradeCounter + 1; // increment counter
34
35 // get next grade from user
36 gradeString = JOptionPane.showInputDialog("Enter Integer Grade or -1 to Quit:" );
37
38
39 // convert gradeString to int
40 grade = Integer.parseInt( gradeString );
41
42 } // end while
43
44 // termination phase
45 DecimalFormat twoDigits = new DecimalFormat( "0.00" );
46
47 // if user entered at least one grade...
48 if ( gradeCounter != 0 ) {
49
50 // calculate average of all grades entered
51 average = (double) total / gradeCounter;
52
53 // display average with two digits of precision
54 JOptionPane.showMessageDialog( null,"Class average is " + twoDigits.format( average ),
55 "Class Average", JOptionPane.INFORMATION_MESSAGE );
56
57
58 } // end if part of if...else
59
60 else // if no grades entered, output appropriate message
61 JOptionPane.showMessageDialog( null, "No grades were entered",
62 "Class Average", JOptionPane.INFORMATION_MESSAGE );
63
64 System.exit( 0 ); // terminate application
65
66 } // end main
67
68 } // end class Average2
4.10 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)
• Nested control structures
Initialize passes to zero
Initialize failures to zero
Initialize student to one
While student counter is less than or equal to ten
Input the next exam result
If the student passed
Add one to passes
else
Add one to failures
Add one to student counter
Print the number of passes
Print the number of failures
If more than eight students passed
Print “Raise tuition”Pseudocode for examination-results problem.
1 // Fig. 4.11: Analysis.java
2 // Analysis of examination results.
3 import javax.swing.JOptionPane;
4
5 public class Analysis {
6
7 public static void main( String args[] )
8 {
9 // initializing variables in declarations
10 int passes = 0; // number of passes
11 int failures = 0; // number of failures
12 int studentCounter = 1; // student counter
13 int result; // one exam result
14
15 String input; // user-entered value
16 String output; // output string
17
18 // process 10 students using counter-controlled loop
19 while ( studentCounter <= 10 ) {
20
21 // prompt user for input and obtain value from user
22 input = JOptionPane.showInputDialog("Enter result (1 = pass, 2 = fail)" );
23
24
25 // convert result to int
26 result = Integer.parseInt( input );
27
28 // if result 1, increment passes; if...else nested in while
29 if ( result == 1 )
30 passes = passes + 1;
31
32 else // if result not 1, increment failures
33 failures = failures + 1;
34
35 // increment studentCounter so loop eventually terminates
36 studentCounter = studentCounter + 1;
37
38 } // end while
39
40 // termination phase; prepare and display results
41 output = "Passed: " + passes + "\nFailed: " + failures;
42
43 // determine whether more than 8 students passed
44 if ( passes > 8 )
45 output = output + "\nRaise Tuition";
46
47 JOptionPane.showMessageDialog( null, output, "Analysis of Examination Results",
48 JOptionPane.INFORMATION_MESSAGE );
49
50
51 System.exit( 0 ); // terminate application
52
53 } // end main
54
55 } // end class Analysis
4.11 Compound Assignment Operators
• Assignment Operators
– Abbreviate assignment expressions
– Any statement of form
• variable = variable operator expression;
– Can be written as
• variable operator= expression;
–e.g., addition assignment operator +=
• c = c + 3
– can be written as
• c += 3
4.12 Increment and Decrement Operators
• Unary increment operator (++)
– Increment variable’s value by 1
• Unary decrement operator (--)
– Decrement variable’s value by 1
• Preincrement / predecrement operator
• Post-increment / post-decrement operator
1 // Fig. 4.14: Increment.java
2 // Preincrementing and postincrementing operators.
3
4 public class Increment {
5
6 public static void main( String args[] )
7 {
8 int c;
9
10 // demonstrate postincrement
11 c = 5; // assign 5 to c
12 System.out.println( c ); // print 5
13 System.out.println( c++ ); // print 5 then postincrement
14 System.out.println( c ); // print 6
15
16 System.out.println(); // skip a line
17
18 // demonstrate preincrement
19 c = 5; // assign 5 to c
20 System.out.println( c ); // print 5
21 System.out.println( ++c ); // preincrement then print 6
22 System.out.println( c ); // print 6
23
24 } // end main
25
26 } // end class Increment
5
5
65
6
6
