Control structure and Looping statements

of
Lecture C
Lesson 3: Conditions and Loops
Unit 1: The if Statement

of
Lecture C
The if Statement
• The Java if statement has the following syntax:
if (boolean-condition)
statement;
• If the Boolean condition is true, the statement is
executed; if it is false, the statement is skipped
• This provides basic decision making capabilities

of
Lecture C
Tempreture
class Temperature {
static final int THRESHOLD = 65;
public static void main(String[] args) {
InputRequestor input = new InputRequestor();
int temperature =
input.requestInt(“Enter the temperature:”);
System.out.println(“Current temperature “+
temperature);
if (temperature < THRESHOLD)
System.out.println(“It’s cold in here!”);
}
}

of
Lecture C
If statement flow diagram
if (condition)
statement;
condition
statement
true

of
Lecture C
Boolean Expressions
• The condition of an if statement must evaluate to a true
or false result
• Java has several equality and relational operators:
• More complex Boolean expressions are also possible
Operator
Meaning
==
equal to
!=
not equal to
<
less than
<=
less than or equal to
>
greater than
>=
greater than or equal to

of
Lecture C
Block Statements
• Several statements can be grouped together into a block
statement
• Blocks are delimited by braces
• A block statement can be used wherever a statement is
called for in the Java syntax
if (boolean-condition){
statement1;
statement2;
…
}

of
Lecture C
Example - Temperature2
class Temperature2 {
static final int THRESHOLD = 65;
int temperature =
input.requestInt(“Enter the temperature:”);
System.out.println(“Current temperature “+
temperature);
if (temperature < THRESHOLD) {
System.out.println(“It’s cold in here!”);
System.out.println(“But we’ll survive.”);
}
}
}

of
Lecture C
If .. Else Statement
• An else clause can be added to an if statement to
make it an if-else statement:
if (condition)
statement1;
else
statement2;
• If the condition is true, statement1 is executed; if the
condition is false, statement2 is executed

of
Lecture C
Example - Temperature3
class Temperature3 {
static final int FREEZING_POINT = 32;
int temperature =
input.requestInt(“Enter temperature:”);
if (temperature <= FREEZING_POINT)
System.out.println(“It’s freezing!”);
else
System.out.println(“Above freezing.”);
}
}

of
Lecture C
If/else flow diagram
if (condition)
statement1;
else
statement2;
condition
statement2
true
statement1

of
Lecture C
Nested If statements
• Since an “If” statement is a statement, it can appear inside
another if statement.
if (condition1)
if (condition2)
statement;
• It can also appear in an “else” clause
if (condition1)
statement1;
else if (condition2)
statement2;

of
Lecture C
Nested If Example
// Reads 2 integers and compares them
class CompareExample {
int a = input.requestInt(“First number:”);
int b = input.requestInt(“Second number:”);
if (a != b){
if (a > b)
System.out.println(a+” is greater”);
else
System.out.println(b+” is greater”);
}else
System.out.println(“the numbers are equal”);
}
}

of
Lecture C
Checking your Input
• When requesting input from the user, keep in mind that the input may be invalid.
• It is good practice to check the validity of user input
int numberOfItems =
input.requestInt(“Enter number of items:”);
if (numberOfItems < 0) {
System.out.println(
“Number of items must be positive!”);
} else {
double price = numberOfItems * ITEM_PRICE;
System.out.println(“The total price is:“ +price);
}

of
Lecture C
Lesson 3: Conditions and Loops
Unit 2: Boolean Expressions

of
Lecture C
Logical Operators
• Boolean expressions may be combined using logical
operators
• There are three logical operators in Java:
• They all take Boolean operands and produce Boolean
results
• Logical NOT is unary (one operand), but logical AND and
OR are binary (two operands)
Operator
Operation
!
Logical NOT
&&
Logical AND
||
Logical OR

of
Lecture C
Logical NOT
• The logical NOT is also called logical negation or logical
complement
• If a is true, !a is false; if a is false, then !a is true
• Logical expressions can be shown using truth tables
a
!a
false
true
true
false

of
Lecture C
Logical AND
• The expression a && b is true if both a and b are true,
and false otherwise
• Truth tables show all possible combinations of all terms
a
b
a && b
false
false
false
false
true
false
true
false
false
true
true
true

of
Lecture C
Logical OR
• The expression a || b is true if a or b or both are true,
and false otherwise
a
b
a || b
false
false
false
false
true
true
true
false
true
true
true
true

of
Lecture C
Logical Operators
• Logical operators are used to form more complex logical
expressions
• Logical operators have precedence relationships between
themselves and other operators
if (a<1 || a%2!=0)
System.out.println(
“The input should be an even even number!”);

of
Lecture C
Logical Operators
• Full expressions can be evaluated using truth tables
a < 1
a%2!=0
a<1 || a%2=0
false
false
false
false
true
false
true
false
false
true
true
true

of
Lecture C
Boolean variables
• Boolean expressions can be assigned to Boolean
variables
• Boolean variables are Boolean expressions
boolean b, c;
b = (x > 17);
c = (x>17) && (x<60);
boolean b, c;
b = (x > 17);
c = b && (x<60);
if (c)
System.out.println(“x is in range”);

of
Lecture C
Example - RightTriangle
// Receives the length of the edges of a triangle
// and determine if this is a right triangle
class RightTriangle {
float a = input.requestInt(“Edge1:”);
float b = input.requestInt(“Edge2:”);
float c = input.requestInt(“Hypotenuse:”);
boolean test = a*a+b*b == c*c;
if (test)
System.out.println(“It’s a right triangle”);
else
System.out.println(“It’s not a right triangle”);
}
}

of
Lecture C
Lesson 3: conditions and loops
Unit C3: The while Statement

of
Lecture C
The while statement
• A while statement has the following syntax:
while (condition)
statement;
• If the condition is true, the statement is executed; then
the condition is evaluated again
• The statement is executed over and over until the
condition becomes false
• If the condition of a while statement is false initially, the
statement is never executed
• Therefore, we say that a while statement executes zero
or more times

of
Lecture C
While statement flow diagram
while (condition)
statement;
condition
statement
true

of
Lecture C
Example - Counter
// Counts from 1 to 5
class Counter {
static final int LIMIT = 5;
int count = 1;
while (count <= LIMIT) {
System.out.println(count);
count = count + 1;
}
System.out.println(“done”);
}
}

of
Lecture C
Examples - Factors
// Gets an integer and prints its factors
class FactorsExample {
int a = input.requestInt(“Enter a number:”);
int i = 1;
System.out.println(“The divisors of “+a+” are:”);
while (i <= a) {
if (a%i == 0) {
System.out.println(i);
}
i = i + 1;
}
}
}

of
Lecture C
Infinite Loops
• The body of a while loop must eventually make the
condition false
• If not, it is an infinite loop, which will execute until the user
interrupts the program
• This is a common type of logical error -- always double
check that your loops will terminate normally

of
Lecture C
Example - Forever
// This program contains an infinite loop
class Forever {
static final int LIMIT = 25;
int count = 1;
while (count <= LIMIT) {
System.out.println(count);
count = count - 1;
}
}
}

of
Lecture C
Unit 4: More conditionals

of
Lecture C
The Conditional Operator
• Java has a conditional operator that evaluates a Boolean
condition that determines which of two expressions is
evaluated
• The result of the chosen expression is the result of the
entire conditional operator
• Its syntax is:
condition ? expression1 :
expression2
• If the condition is true, expression1 is evaluated; if it is
false, expression2 is evaluated

of
Lecture C
• It is similar to an if-else statement, except that it is an
expression that returns a value
• For example:
• If a is greater that b, then a is assigned to max;
otherwise, b is assigned to max
• The conditional operator is ternary, meaning it requires
three operands
int max = (a > b) ? a : b;

of
Lecture C
• Another example:
• If count equals 1, "Dime" is printed, otherwise
"Dimes" is printed
System.out.println ("Your change is " + count +
((count == 1) ? "Dime" : "Dimes”));

of
Lecture C
Another Selection Statement
• The if and the if-else statements are selection
statements, allowing us to select which statement to
perform next based on some Boolean condition
• Another selection construct, called the switch statement,
provides another way to choose the next action
• The switch statement evaluates an expression, then
attempts to match the result to one of a series of values
• Execution transfers to statement list associated with the
first value that matches

of
Lecture C
The switch Statement
• The syntax of the switch statement is:
switch (expression) {
case value1:
statement-list1
case value2:
statement-list2
case …
}

of
Lecture C
• The expression must evaluate to an integral value, such
as an integer or character
• The break statement is usually used to terminate the
statement list of each case, which causes control to jump
to the end of the switch statement
• A default case can be added to the end of the list of
cases, and will execute if no other case matches

of
Lecture C
/**
* A client that enables you to connect to the
* bank server and make remote banking operations...
*/
public class BankClient {
public static final int VIEW_BALANCE = 1;
public static final int VIEW_SAVINGS = 2;
public static final int CASH_TRANSFER = 3;
public static final int VIEW_LAST_OPERATIONS = 4;
// ...

of
Lecture C
// Inside the main loop of the client:
int option =
InputRequestor.requentInt(“Enter your choice:”);
switch(option) {
case VIEW_BALANCE:
showBalance();
break;
case VIEW_SAVINGS:
showSavings();
break;
default:
output.showMessage(“No such option!”);
}

of
Lecture C
Unit 5: Shorthand Operators

of
Lecture C
Shorthand Operators
• Many operations are very commonly used
• Java has shorthand notations for these
 increment and decrement operators
 assignment operators
x = x + 1;
sum = sum + x;

of
Lecture C
The Increment and Decrement Operators
• The increment operator (++) adds one to its integer or
floating point operand
• The decrement operator (--) subtracts one
• The statement
is essentially equivalent to
count++;
count = count + 1;

of
Lecture C
• The increment and decrement operators can be applied
in prefix (before the variable) or postfix (after the variable)
form
• When used alone in a statement, the prefix and postfix
forms are basically equivalent. That is,
is equivalent to
count++;
++count;

of
Lecture C
• When used in a larger expression, the prefix and postfix
forms have a different effect
• In both cases the variable is incremented (decremented)
• But the value used in the larger expression depends on
the form
Expressions
Operation
Value Of expression
count++
add 1
old value
++count
add 1
new value
count--
subtract 1
old value
--count
subtract 1
new value

of
Lecture C
• If count currently contains 45, then
assigns 45 to total and 46 to count
• If count currently contains 45, then
assigns the value 46 to both total and count
total = count++;
total = ++count;

of
Lecture C
• If sum contains 25, what does this statement print?
• Prints the following result:
25 27 27 27
• sum contains 26 after the line is complete
System.out.println (sum++ + " " +
++sum + " " +
sum + " " +
sum--);

of
Lecture C
Assignment Operators
• Often we perform an operation on a variable, then store
the result back into that variable
• Java provides assignment operators that simplify that
process
• For example, the statement
is equivalent to
sum += value;
sum = sum + value;

of
Lecture C
• There are many such assignment operators, always
written as op= , such as:
Operator
Example
Equivalent to
+=
x+=y
x = x + y
-=
x-=y
x = x - y
*=
x*=y
x = x * y
/=
x/=y
x = x / y
%=
x%=y
x = x % y

of
Lecture C
• The right hand side of an assignment operator can be a
complete expression
• The entire right-hand expression is evaluated first, then
combined with the additional operation
• Therefore
result /= total-MIN;
is equivalent to
result /= total-MIN;
result = result / (total-MIN);

of
Lecture C
Unit C6: More Repetition

of
Lecture C
More Repetition Constructs
• In addition to while loops, Java has two other
constructs used to perform repetition:
 the do statement
 the for statement
• Each loop type has its own unique characteristics
• You must choose which loop type to use in each situation

of
Lecture C
The do Statement
• The do statement has the following syntax:
do
statement
while (condition);
• The statement is executed until the condition becomes
false
• It is similar to a while statement, except that its
termination condition is evaluated after the loop body

of
Lecture C
The do Statement
• The key difference between a do loop and a while loop
is that the body of the do loop will execute at least once
• If the condition of a while loop is false initially, the body
of the loop is never executed
• Another way to put this is that a while loop will execute
zero or more times and a do loop will execute one or
more times

of
Lecture C
Do Statement Example
// Gets an integer and prints its factors
class AvgExample {
public static void main(String[] args){
double x, sum=0, count=-1;
do {
x = input.RequestDouble(“Next number:”);
sum += x;
count++;
} while (x != 0);
// 0 is a flag indicating end of input
System.out.println(“The average is “+sum/count);
}
}

of
Lecture C
The do Statement flow diagram
statement
condition
false
true

of
Lecture C
The for Statement
• Many loops have a common pattern, captured by the for
statement
• The syntax of the for loop is
for (intialization; condition; increment)
statement;
• This is equivalent to
initialization;
while (condition) {
statement;
increment;
}

of
Lecture C
The for Statement: examples
• Examples:
for (int count=1; count < 75; count++) {
System.out.println (count);
}
for (int num=1; num <= max; num = num * 2) {
System.out.println (“Next power of 2: “ + num);
}

of
Lecture C
The for Statement
• The initialization is always performed once
• The condition of a for statement is tested prior to
executing the loop body (like in the while statement)
• Therefore, a for loop will execute zero or more times
• For loops are well suited for cases where the number of
iterations is known beforehand
• The increment is executed after each iteration of the loop

of
Lecture C
Omitting parts in a for Statement
• Each expression in the header of a for loop is optional
 If the initialization is left out, no initialization is performed
 If the condition is left out, it is always considered to be true, and
therefore makes an infinite loop
 If the increment is left out, no increment operation is performed
• Both semi-colons are always required
for (;;) {// an infinite loop
System.out.println (“beep”);
}
// compute a value count
for (; count < max ; count ++ ) {
System.out.println (count);
}

of
Lecture C
The for Statement flow diagram
statement
condition
false
true
initialization
increment

of
Lecture C
Multiplication Table Example
class MultiplicationTable {
for(int j=1 ; j <= 10 ; j++) {
for(int k=1 ; k <= 10 ; k++)
System.out.print(j*k);
System.out.println();
}
}
}

of
Lecture C
The break and continue statements
• The break statement, which we used with switch
statements, can also be used inside a loop
• When the break statement is executed, control jumps to
the statement after the loop (the condition is not
evaluated again)
• A similar construct, the continue statement, can also be
executed in a loop
• When the continue statement is executed, control
jumps to the end of the loop and the condition is
evaluated

of
Lecture C
Break and Continue Example
class AvgExample2 {
InputRequestor in = new InputRequestor();
double x, sum = 0; count = 0;
while(true){
x = in.RequestDouble();
if (x == 0)
break;
if (x < 0) {
System.out.println(“Only positive numbers!”);
continue;
}
sum += x ;
count ++ ;
} // continued on next page

of
Lecture C
Break and Continue Example (2)
System.out.println(“The average is “+sum/count);
}
}

of
Lecture C
Why do We Need Indentation?
class Mystery {
InputRequestor in = new InputRequestor();
int dimension =
in.requestInt(“Please enter the dimension”);
for (int j = 0; j < dimension; j++) {
for (int k = 1; k < dimension - j; k++) {
System.out.print(" ");
}
for (int k = 0; k < j; k++) {
System.out.print("*");
}
System.out.println();
}}}

Control structure and Looping statements

More Related Content

Similar to Control structure and Looping statements (20)

More from BalaKrishnan466 (15)

Recently uploaded (20)

Control structure and Looping statements