1 CSCE 1030 Computer Science 1 Control Statements in Java.

CSCE 1030

Computer Science 1

Control Statements in Java

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

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

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

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

if statement

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

if (StudentGrade < 60) {

letterGrade=‘F’;

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

Prototype

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);

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);

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

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

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

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!

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

Integers Character constant

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

Declared with keyword final

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

default case for grade less than 60

Call GradeBook public methods to count grades

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 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 1 // Fig. 5.13: ContinueTest.java

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

3 public class ContinueTest

5 public static void main( String args[] )

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

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

10 continue; // skip remaining code in loop

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

13 } // end for

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

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

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

1 // Fig. 5.1: WhileCounter.java

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

4 public class WhileCounter

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

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

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

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

14 } // end while

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

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

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

10 Set the class average to the total divided by ten

11 Print the class average

Outline

Assign a value to instance variable courseName

Declare method setCourseName

Declare method getCourseName

OutlineDeclare method displayMessage

Declare method determineClassAverage

Declare and initialize Scanner variable input

Declare local int variables total, gradeCounter, grade and average

Outline while loop iterates as long as gradeCounter <= 10

Increment the counter variable gradeCounter

Calculate average grade

Display results

OutlineCreate a new GradeBook object

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

Call GradeBook’s determineClassAverage method

Integer division

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

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

Fig. 4.8 | Class-average problem pseudocode algorithm with

sentinel-controlled repetition. 1 Initialize total to zero

2 Initialize counter to zero

4 Prompt the user to enter the first grade

5 Input the first grade (possibly the sentinel)

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)

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

Outline

Assign a value to instance variable courseName

Declare method setCourseName

Declare method getCourseName

OutlineDeclare method displayMessage

Declare method determineClassAverage

Declare and initialize Scanner variable input

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

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

Calculate average grade using (double) to perform explicit conversion

Display average grade

OutlineCreate a new GradeBook object

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

Call GradeBook’s determineClassAverage method

Type Casting

Explicit conversion Performed by user with unary cast operator

Implicit conversion (promotion) Done by Java

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

do…while Repetition Statement

First executes the body loop, then tests the loop condition

42 1 // Fig. 5.7: DoWhileTest.java

2 // do...while repetition statement.

4 public class DoWhileTest

8 int counter = 1; // initialize counter

13 ++counter;

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

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

The for loop

Fig. 5.3 | for statement header components.

Not a comma!

No semi-colon

The for loop as a while loop

for (initialization; loopContinuationCondition; increment ) statement;

is the same as

initialization;while ( loopContinuationCondition )

{ statement; increment;}

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 1 // Fig. 5.5: Sum.java

2 // Summing integers with the for statement.

4 public class Sum

8 int total = 0; // initialize total

10 // total even integers from 2 through 20

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

12 total += number;

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 1 // Fig. 5.6: Interest.java

2 // Compound-interest calculations with for.

4 public class Interest

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

12 // display headers

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

Java treats floating-points as type double

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

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

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

18 // calculate new amount for specified year

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

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 1 // Fig. 5.2: ForCounter.java

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

4 public class ForCounter

8 // for statement header includes initialization,

9 // loop-continuation condition and increment

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

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

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

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.

OutlineDeclare processExamResults’

local variables

while loop iterates as long as studentCounter <= 10

Outline

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

Determine whether more than eight students passed the exam

Outline Create an Analysis object

More than 8 students passed the exam

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

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

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

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

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)

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

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

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

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

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

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

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

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

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.

expression !expression false true true false

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

Conditional AND truth table

Conditional OR truth table

Boolean logical AND truth table

Boolean logical inclusive OR truth table

Boolean logical exclusive OR truth table

Logical negation truth table

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

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

Transcript of 1 CSCE 1030 Computer Science 1 Control Statements in Java.

classNORTH 1030

Degree Worksheet: Computer Information Systems- CIT 150 Introduction to Java Programming 3 CIS 1030 - CIT 151 Advanced Java Programming 3 - CIT 149 Website Scripting I 3 - CIT 250

CSCE 314 Programming Languages - Texas A&M …faculty.cse.tamu.edu/hlee/csce314/finalReview1.pdf¢ 1990’s: Haskell, Java, Python ... Backus-Naur Form (BNF) Lee CSCE 314 TAMU 9 ...

CSCE Oct Newsletter

Montgomery 1030

CSCE 1020.002

CSCE 314 Programming Languages Concurrency in Javafaculty.cse.tamu.edu/hlee/csce314/lec15-Java-concurrency.pdf · 2015-11-23 · • In Java, concurrency features partially part of

ITU Normal.dot · Web view Оперативный бюллетень МСЭ No. 1030 – 19 Оперативный бюллетень МСЭ No. 1030 – 16 M:\COMP\COMP\UIT-T\BE\2013\1030\1030-R.docx

CSCE 314 Programming Languages JVM - ecology lab · 2020. 8. 10. · Lee CSCE 314 TAMU JVM and Java (cont.) Although JVM was primarily designed for Java, it is theoretically possible

CSCE 1030 Computer Science 1 First Day. Course Dr. Ryan Garlick garlick Office: Research Park F201 B –Inside the Computer Science department.

1 CSCE 1030 Computer Science 1 Arrays Chapter 7 in Small Java.

CSCE 510 - Systems Programming Lecture 17 Sockets CSCE March 20, 2013.

Internet Security CSCE 813 IPsec. CSCE 813 - Farkas2 Reading Oppliger: Chapter 14.

CSCE 510 - Systems Programming Lecture 09 –Shells CSCE 510 Feb 13, 2013.

Workflow Expansion & DBMS Loggingcsce.uark.edu/~cwt/COURSES/2009-08--CSCE-4613--AI/TERM... · Web viewUniversity of Arkansas – CSCE Department CSCE 4613 Artificial Intelligence

DPF-2030/2030E/2030-SDPF-1030/1030E/1030-S - …diagramas.diagramasde.com/audio/Kenwood_DPF-1030,2030.pdf · dpf-1030/1030e/1030-s dpf-2030/2030e/2030-s ... dpf-1030/2030 2 contents

CSCE Workshops Sellinginadowneconomy

CSCE 510 - Systems Programming Lecture 02 - System Calls CSCE 510 Jan 16, 2013.

CSCE 314 Programming Languages Concurrency in Java · libraries (Java concurrency API) • In Erlang, Oz, threads, futures, etc. integral part of the language Next: mechanics of Java’s

CSCE 314 Programming Languages Java Generics Ifaculty.cse.tamu.edu/hlee/csce314/lec13-Java-genericsA.pdf · Lee CSCE 314 TAMU Java Generics: History •Pizza: 1996-97, extended Java