1 csce 1030 computer science 1 control statements in java

1

CSCE 1030

Computer Science 1

Control Statements in Java

2

Control Structures

Sequential execution Statements are normally executed one after

the other in the order in which they are written Transfer of control

Branch to another statement out normal flow We not always need to execute the next

statement in sequence Use goto statement

Not a structured programming element

3

Control Structures – cont’d

Selection Statements if statement

Allows single-selection per if statement

if…else statement Allows double-selection statement

switch statement Allows multiple-selection

4

Control Structures – cont’d

Repetition (Looping) statements Repeatedly executes action(s) while loop-

continuation condition remains true while statement

Loop body is executed zero or more times

do…while statement Loop body is executed one or more times

for statement Loop body is executed zero or more times

5

Top-Down, Stepwise Refinement

Top step: Start with less detailed algorithmic solution usually one statement

First refinement: Detail the solution into multiple statements which uses only the sequence structure yet more detailed

Second refinement: Involve variables, and variety of control structures where necessary most detailed

6

if statement

if (condition) {statement(s) if condition is true

}

if (StudentGrade < 60) {

letterGrade=‘F’;

System.out.println(“Student has failed”);

}

Prototype

7

if ... else statement

if (condition) {statement(s) if condition is true

}else {

statement(s) if condition is false}

if (sex = ‘F’) { var1=“Madam”; System.out.println(“Good morning ” + var1);

}else { var1=“Sir”; System.out.println(“Good morning ” + var1);

}

8

if ... else statement – cont’d

Ternary operator ( ? : )(takes 3 operands)

Statement condition ? value if true : value if false;

int a=10;int b=20;String result=a>b ? “a greater than b”:“a is less than b”;System.out.println(“The conclusion is: ” + result);

9


Nested if…else statements if…else block contains several if…else

statements in if, in else or in both Blocks

Braces { } associate statements into blocks Blocks can replace individual statements as

an if body

10


Empty statements Put a semicolon ( ; ) in place of a statement Can replace an if body

11

Problems with if ... else statement

Dangling-else problem Each else should be preceded by an if

Logic errors – not necessarily with if .. else only Fatal logic errors

Program terminates before normal end Nonfatal logic errors

Program yields incorrect results

12

switch Multiple-Selection Statement

Allows multiple selections for cases where if.. else remains insufficient

Provide a default case in switch statements. Also called a fall-through Don’t forget the break!

13

switch Multiple-Selection Statement – cont’d Expression in each case

Integers Character constant

E.g., ‘F’, ‘16’ or ‘#’ Constant variable

Declared with keyword final

14

14

2005 Pearson Education, Inc. All rights reserved.

15


16

16

Loop condition uses method hasNext to determine whether there is more data to input

switch statement determines which case label to execute,

depending on controlling expression

(grade / 10 ) is controlling expression


17

17

default case for grade less than 60


18

18


19

19

Call GradeBook public methods to count grades


20

20


21

switch Multiple-Selection Statement – break and continue Statements break/continue

Alter flow of control break statement

Causes immediate exit from control structure Used in while, for, do…while or switch

statements continue statement

Skips remaining statements in loop body Proceeds to next iteration

Used in while, for or do…while statements

22

22 1 // Fig. 5.12: BreakTest.java 2 // break statement exiting a for statement. 3 public class BreakTest 4 { 5 public static void main( String args[] ) 6 { 7 int count; // control variable also used after loop terminates 8 9 for ( count = 1; count <= 10; count++ ) // loop 10 times 10 { 11 if ( count == 5 ) // if count is 5, 12 break; // terminate loop 13 14 System.out.printf( "%d ", count ); 15 } // end for 16 17 System.out.printf( "\nBroke out of loop at count = %d\n", count ); 18 } // end main 19 } // end class BreakTest

1 2 3 4 Broke out of loop at count = 5

Loop 10 times

Exit for statement (break) when count equals 5


23

23 1 // Fig. 5.13: ContinueTest.java

2 // continue statement terminating an iteration of a for statement.

3 public class ContinueTest

4 {

5 public static void main( String args[] )

6 {

7 for ( int count = 1; count <= 10; count++ ) // loop 10 times

8 {

9 if ( count == 5 ) // if count is 5,

10 continue; // skip remaining code in loop

11

12 System.out.printf( "%d ", count );

13 } // end for

14

15 System.out.println( "\nUsed continue to skip printing 5" );

16 } // end main

17 } // end class ContinueTest 1 2 3 4 6 7 8 9 10 Used continue to skip printing 5

Loop 10 times

Skip line 12 and proceed to line 7 when count equals 5


24

Repetition (Looping) statements - While

while condition {statement 1; statement 2;

}

a=10, b=20;while (a < b) {

System.out.println(“a=” + a + “ b=” + b;a=a*10;

}

This part is called the loop body

25

Counter Controlled Repetition

Counter-controlled repetition requires: Control variable (loop counter): The variable

which keeps track of the number of times a loop is iterated

Initial value of the control variable Increment/decrement of control variable

through each loop to make sure that loop eventually ends

No indefinite loop Loop-continuation condition that tests for the

final value of the control variable

26

1 // Fig. 5.1: WhileCounter.java

2 // Counter-controlled repetition with the while repetition statement.

3

4 public class WhileCounter

5 {


7 {

8 int counter = 1; // declare and initialize control variable

9

10 while ( counter <= 10 ) // loop-continuation condition

11 {

12 System.out.printf( "%d ", counter );

13 ++counter; // increment control variable by 1

14 } // end while

15

16 System.out.println(); // output a newline

17 } // end main

18 } // end class WhileCounter 1 2 3 4 5 6 7 8 9 10

Control-variable name is counter

Control-variable initial value is 1

Condition tests for counter’s final value

Increment for counter

A simple example with while loop


27

Fig. 4.5 | Pseudocode algorithm that uses counter-controlled repetition to solve the class-average problem.

1 Set total to zero

2 Set grade counter to one

3

4 While grade counter is less than or equal to ten

5 Prompt the user to enter the next grade

6 Input the next grade

7 Add the grade into the total

8 Add one to the grade counter

9

10 Set the class average to the total divided by ten

11 Print the class average

28

Outline

Assign a value to instance variable courseName

Declare method setCourseName

Declare method getCourseName


29

OutlineDeclare method displayMessage

Declare method determineClassAverage

Declare and initialize Scanner variable input

Declare local int variables total, gradeCounter, grade and average


30

30

Outline while loop iterates as long as gradeCounter <= 10

Increment the counter variable gradeCounter

Calculate average grade

Display results


31

OutlineCreate a new GradeBook object

Pass the course’s name to the GradeBook constructor as a string

Call GradeBook’s determineClassAverage method


32

Integer division

Division of two integer operands yield a truncated integer result 12 / 5 = 2 63 / 6 = 10 17 / 2 = 8

33

Sentinel Controlled Repetition

Also called indefinite repetition A sentinel value (aka signal, dummy or flag

value) is used to indicate loop end This value is some value that is for sure will

not occur as input value for the problem It is a good idea to let user know about the

sentinel value when you get input to the program

34

Fig. 4.8 | Class-average problem pseudocode algorithm with

sentinel-controlled repetition. 1 Initialize total to zero

2 Initialize counter to zero

3

4 Prompt the user to enter the first grade

5 Input the first grade (possibly the sentinel)

6

7 While the user has not yet entered the sentinel

8 Add this grade into the running total

9 Add one to the grade counter

10 Prompt the user to enter the next grade

11 Input the next grade (possibly the sentinel)

12

13 If the counter is not equal to zero

14 Set the average to the total divided by the counter

15 Print the average

16 else

17 Print “No grades were entered” 2005 Pearson Education, Inc. All rights reserved.

35

Outline

Assign a value to instance variable courseName

Declare method setCourseName

Declare method getCourseName


36

OutlineDeclare method displayMessage

Declare method determineClassAverage

Declare and initialize Scanner variable input

Declare local int variables total, gradeCounter and grade and double variable average


37

Outlinewhile loop iterates as long as grade != the sentinel value, -1

Calculate average grade using (double) to perform explicit conversion

Display average grade

Display “No grades were entered” message 2005 Pearson Education, Inc. All rights reserved.

38

OutlineCreate a new GradeBook object

Pass the course’s name to the GradeBook constructor as a string

Call GradeBook’s determineClassAverage method


39

Type Casting

Explicit conversion Performed by user with unary cast operator

Implicit conversion (promotion) Done by Java

40

Type Casting – cont’d

In Fig. 4.9 line 72

average = total / gradeCounter; Although average was declared as double (line 45), the

integer division above yields an integer value b/c both total and gradeCounter are integer variables

To preserve the fraction in result, use unary cast operator via explicit conversion

average = (double) total / gradeCounter; This converts the type of variable total to double

temporarily Then, Java applies promotion (implicit conversion) to convert

type of variable gradeCounter to double temporarily

41

do…while Repetition Statement

First executes the body loop, then tests the loop condition

42

42 1 // Fig. 5.7: DoWhileTest.java

2 // do...while repetition statement.

3

4 public class DoWhileTest

5 {


7 {

8 int counter = 1; // initialize counter

9

10 do

11 {


13 ++counter;

14 } while ( counter <= 10 ); // end do...while

15

16 System.out.println(); // outputs a newline

17 } // end main

18 } // end class DoWhileTest 1 2 3 4 5 6 7 8 9 10

Variable counter’s value is displayed before testing counter’s final value


43

The for loop

Fig. 5.3 | for statement header components.

Not a comma!

No semi-colon


44

The for loop as a while loop

for (initialization; loopContinuationCondition; increment ) statement;

is the same as

initialization;while ( loopContinuationCondition )

{ statement; increment;}

45

Examples Using the for Statement

Varying control variable in for statement Vary control variable from 1 to 100 in increments of 1

for ( int i = 1; i <= 100; i++ ) Vary control variable from 100 to 1 in increments of –1

for ( int i = 100; i >= 1; i-- ) Vary control variable from 7 to 77 in increments of 7

for ( int i = 7; i <= 77; i += 7 ) Vary control variable from 20 to 2 in decrements of 2

for ( int i = 20; i >= 2; i -= 2 ) Vary control variable over the sequence: 2, 5, 8, 11, 14, 17, 20

for ( int i = 2; i <= 20; i += 3 ) Vary control variable over the sequence: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0

for ( int i = 99; i >= 0; i -= 11 )


46

46 1 // Fig. 5.5: Sum.java

2 // Summing integers with the for statement.

3

4 public class Sum

5 {


7 {

8 int total = 0; // initialize total

9

10 // total even integers from 2 through 20

11 for ( int number = 2; number <= 20; number += 2 )

12 total += number;

13

14 System.out.printf( "Sum is %d\n", total ); // display results

15 } // end main

16 } // end class Sum Sum is 110

increment number by 2 each iteration


47

47 1 // Fig. 5.6: Interest.java

2 // Compound-interest calculations with for.

3

4 public class Interest

5 {


7 {

8 double amount; // amount on deposit at end of each year

9 double principal = 1000.0; // initial amount before interest

10 double rate = 0.05; // interest rate

11

12 // display headers

13 System.out.printf( "%s%20s\n", "Year", "Amount on deposit" );

14

Java treats floating-points as type double

Second string is right justified and displayed with a field width of 20


48

4815 // calculate amount on deposit for each of ten years

16 for ( int year = 1; year <= 10; year++ )

17 {

18 // calculate new amount for specified year

19 amount = principal * Math.pow( 1.0 + rate, year );

20

21 // display the year and the amount

22 System.out.printf( "%4d%,20.2f\n", year, amount );

23 } // end for

24 } // end main

25 } // end class Interest Year Amount on deposit 1 1,050.00 2 1,102.50 3 1,157.63 4 1,215.51 5 1,276.28 6 1,340.10 7 1,407.10 8 1,477.46 9 1,551.33 10 1,628.89

Calculate amount with for statement


49

49 1 // Fig. 5.2: ForCounter.java

2 // Counter-controlled repetition with the for repetition statement.

3

4 public class ForCounter

5 {


7 {

8 // for statement header includes initialization,

9 // loop-continuation condition and increment

10 for ( int counter = 1; counter <= 10; counter++ )


12

13 System.out.println(); // output a newline

14 } // end main

15 } // end class ForCounter 1 2 3 4 5 6 7 8 9 10

Control-variable name is counter

Control-variable initial value is 1

Condition tests for counter’s final value

Increment for counter


50

Nested Control Statements

Control statements Conditional operations (if, if .. else, switch)

Iterative operations (while, do..while, for)

may occur inside the body of other control statements

51

1 Initialize passes to zero 2 Initialize failures to zero 3 Initialize student counter to one 4 5 While student counter is less than or equal to 10 6 Prompt the user to enter the next exam result 7 Input the next exam result 8 9 If the student passed 10 Add one to passes 11 Else 12 Add one to failures 13 14 Add one to student counter 15 16 Print the number of passes 17 Print the number of failures 18 19 If more than eight students passed 20 Print “Raise tuition”

Fig. 4.11 | Pseudocode for examination-results problem.


52

52

OutlineDeclare processExamResults’

local variables

while loop iterates as long as studentCounter <= 10


53

53

Outline

Determine whether this student passed or failed and increment the appropriate variable

Determine whether more than eight students passed the exam


54

Outline Create an Analysis object

More than 8 students passed the exam


55

Compound Assignment Operators

variable = variable operator expression;where operator is +, -, *, / or % is rewritten as:variable operator= expression;

myVar = myVar+ 7; can be written as

myVar+= 7; Add 7 to the value in variable myVar and

stores the result in variable myVar


56

Fig. 4.14 | Arithmetic compound assignment

operators.

Assignment operator

Sample expression

Explanation Assigns

Assume: int c = 3, d = 5, e = 4, f = 6, g = 12; += c += 7 C = c + 7 10 to c -= d -= 4 d = d - 4 1 to d *= e *= 5 e = e * 5 20 to e /= f /= 3 f = f / 3 2 to f

%= g %= 9 g = g % 9 3 to g


57

Increment and Decrement Operators

Unary increment and decrement operators Unary increment operator (++) adds 1 to its operand Unary decrement operator (--) subtracts 1 from its

operand Prefix increment (and decrement) operator

Change the value of the operand first Then execute the operation in which with the new

value of the operand Postfix increment (and decrement) operator

First use the current value of the operand in the expression in which the operation appears

Then, change the value of the operand


58

Fig. 4.17 | Precedence and associativity

of the operators discussed so far.

Operators Associativity Type ++ -- right to left unary postfix

++ -- + - ( type ) right to left unary prefix * / % left to right Multiplicative + - left to right Additive < <= > >= left to right Relational == != left to right Equality ?: right to left Conditional

= += -= *= /= %= right to left assignment


59

Logical Operators

Logical operators Allows for forming more complex conditions Combines simple conditions

Java logical operators && (conditional AND) || (conditional OR) & (boolean logical AND) | (boolean logical inclusive OR) ^ (boolean logical exclusive OR) ! (logical NOT)


60

Logical Operators – cont’d

Conditional AND (&&) Operator Consider the following if statement

if ( gender == FEMALE && age >= 65 ) ++seniorFemales;

Combined condition is true if and only if both simple conditions are true

Combined condition is false if either or both of the simple conditions are false


61

expression1 expression2 expression1 && expression2 false false False false true False true false False true true True

Fig. 5.14 | && (conditional AND) operator truth table.


62

Logical Operators (Cont.)

Conditional OR (||) Operator Consider the following if statement

if ( ( semesterAverage >= 90 ) || ( finalExam >= 90 )

System.out.println( “Student grade is A” );

Combined condition is true if either or both of the simple condition are true

Combined condition is false if both of the simple conditions are false


63

Fig. 5.15 | || (conditional OR) operator truth table.

expression1 expression2 expression1 || expression2 false false false false true true true false true true true true


64


Short-Circuit Evaluation of Complex Conditions Parts of an expression containing && or ||

operators are evaluated only until it is known whether the condition is true or false

E.g., ( gender == FEMALE ) && ( age >= 65 )

Stops immediately if gender is not equal to FEMALE


65


Boolean Logical Exclusive OR (^) One of its operands is true and the other is false

Evaluates to true Both operands are true or both are false

Evaluates to false

Logical Negation (!) Operator Unary operator


66

expression1 expression2 expression1 ^ expression2 false false false false true true true false true true true false

Fig. 5.16 | ^ (boolean logical exclusive OR) operator truth table.


67

expression !expression false true true false

Fig. 5.17 |! (logical negation, or logical NOT) operator truth table.


68

Conditional AND truth table

Conditional OR truth table

Boolean logical AND truth table


69

69

Boolean logical inclusive OR truth table

Boolean logical exclusive OR truth table

Logical negation truth table


70

70


71

Fig. 5.19 | Precedence/associativity of the operators discussed so far.

Operators Associativity Type

++ -- right to left unary postfix ++ - + - ! (type) right to left unary prefix

* / % left to right multiplicative + - left to right additive < <= > >= left to right relational == != left to right equality & left to right boolean logical AND ^ left to right boolean logical exclusive OR | left to right boolean logical inclusive OR && left to right conditional AND || left to right conditional OR ?: right to left conditional = += -= *= /= %= right to left assignment


72

References

H. M. Deitel, P. J. Deitel, ”Small JAVA How to Program 6th edition”, Pearson/Prentice Hall, 2005.

1 csce 1030 computer science 1 control statements in java

Documents

computer science

java version

multiple statements

editionif statement

control statements

individual statements

switch statements

associate statements