05. Control Structures.ppt

Programming in Java
Topic: Control Flow Statements
By
Ravi Kant Sahu
Asst. Professor, LPU

Selection Statements
Ravi Kant Sahu, Asst. Professor @ Lovely Professional University, Punjab (India)

• Java supports two selection statements: if and switch.
if statement
if (condition) statement1;
else statement2;
• Each statement may be a single statement or a compound statement
enclosed in curly braces (block).
• The condition is any expression that returns a boolean value.
• The else clause is optional.
• If the condition is true, then statement1 is executed. Otherwise,
statement2 (if it exists) is executed.
• In no case will both statements be executed.

Nested ifs
• A nested if is an if statement that is the target of another
if or else.
• In nested ifs an else statement always refers to the
nearest if statement that is within the same block as the
else and that is not already associated with an else.
if (i == 10) {
if (j < 20) a = b;
if (k > 100) c = d; // this if is
else a = c; // associated with this else
}
else a = d; // this else refers to if(i == 10)

The if-else-if Ladder
• A sequence of nested ifs is the if-else-if ladder.
if(condition)
statement;
else if(condition)
statement;
else if(condition)
statement;
...
else
statement;
• The if statements are executed from the top to down.

switch
• The switch statement is Java’s multi-way branch statement.
• provides an easy way to dispatch execution to different parts of your code based
on the value of an expression.
• provides a better alternative than a large series of if-else-if statements.
switch (expression) {
case value1:
// statement sequence
break;
case value2:
break;
...
case valueN:
break;
default:
// default statement sequence
}

• The expression must be of type byte, short, int, char,
String or enum.
• Each of the values specified in the case statements must
be of a type compatible with the expression.
• Each case value must be a unique literal (i.e. constant not
variable).
• Duplicate case values are not allowed.
• The value of the expression is compared with each of the
literal values in the case statements.
• If a match is found, the code sequence following that case
statement is executed.
• If none of the constants matches the value of the
expression, then the default statement is executed.
• The default statement is optional.

• If no case matches and no default is present, then no
further action is taken.
• The break statement is used inside the switch to terminate
a statement sequence.
• When a break statement is encountered, execution
branches to the first line of code that follows the entire
switch statement.

class SampleSwitch {
public static void main(String args[]) {
for(int i=0; i<6; i++)
switch(i) {
case 0:
System.out.println("i is zero.");
break;
case 1:
System.out.println("i is one.");
break;
case 2:
System.out.println("i is two.");
break;
default:
System.out.println("i is greater than 2.");
}
}
}

Nested switch Statements
• When a switch is used as a part of the statement sequence of
an outer switch. This is called a nested switch.
switch(count) {
case 1:
switch(target) { // nested switch
case 0:
System.out.println("target is zero");
break;
case 1: // no conflicts with outer switch
System.out.println("target is one");
break;
}
break;
case 2: // ...

Difference between ifs and switch
• switch can only test for equality, whereas if can evaluate any
type of Boolean expression. That is, the switch looks only for a
match between the value of the expression and one of its case
constants.
• A switch statement is usually more efficient than a set of
nested ifs.
• Note: No two case constants in the same switch can have
identical values. Of course, a switch statement and an
enclosing outer switch can have case constants in common.

Let’s do Something…
Write a menu driven program which prompts the user to enter
[1. Saving Account
2. Current Account]
Ask the user to enter the age. If the age is less than 18 then
print “current account can not be opened” and if the age is less
than 21 but user is eligible for current account then print
“saving account can not be opened but you can open current
account”. Otherwise print “You are not eligible for Saving
Account”.
If the user is eligible for given type of account then print "You
are eligible to open the CURRENT/SAVING account"

Iteration Statements
(Loops)

Iteration Statements
• In Java, iteration statements (loops) are:
– for
– while, and
– do-while
– for each (Enhanced For Loop)
• A loop repeatedly executes the same set of
instructions until a termination condition is
met.

While Loop
• While loop repeats a statement or block while its
controlling expression is true.
• The condition can be any Boolean expression.
• The body of the loop will be executed as long as the
conditional expression is true.
• When condition becomes false, control passes to the
next line of code immediately following the loop.
while(condition)
{
// body of loop
}

class While
{
int n = 10;
char a = 'G';
while(n > 0)
{
System.out.print(a);
n--;
a++;
}
}
}

• The body of the loop will not execute even once if the
condition is false.
• The body of the while (or any other of Java’s loops)
can be empty. This is because a null statement (one
that consists only of a semicolon) is syntactically
valid in Java.

do-while
• The do-while loop always executes its body at least once,
because its conditional expression is at the bottom of the
loop.
do {
// body of loop
} while (condition);
• Each iteration of the do-while loop first executes the body
of the loop and then evaluates the conditional expression.
• If this expression is true, the loop will repeat. Otherwise,
the loop terminates.

for Loop
for (initialization; condition; iteration)
{
// body
}
• Initialization portion sets the value of loop control variable.
• Initialization expression is only executed once.
• Condition must be a Boolean expression. It usually tests the
loop control variable against a target value.
• Iteration is an expression that increments or decrements the
loop control variable.

The for loop operates as follows.
• When the loop first starts, the initialization portion of
the loop is executed.
• Next, condition is evaluated. If this expression is true,
then the body of the loop is executed. If it is false, the
loop terminates.
• Next, the iteration portion of the loop is executed.

class ForTable
{
public static void main(String args[])
{
int n;
int x=5;
for(n=1; n<=10; n++)
{
int p = x*n;
System.out.println(x+"*"+n +"="+ p);
}
}
}

What will be the output?
class Loop
{
public static void main(String args[])
{
for(int i=0; i<5; i++);
System.out.println (i++);
}
}

Declaring loop control variable inside loop
• We can declare the variable inside the initialization
portion of the for.
for ( int i=0; i<10; i++)
{
System.out.println(i);
}
• Note: The scope of this variable i is limited to the for
loop and ends with the for statement.

Using multiple variables in a for loop
• More than one statement in the initialization and iteration
portions of the for loop can be used.
Example 1:
class var2 {
public static void main(String arr[]) {
int a, b;
b = 5;
for(a=0; a<b; a++) {
System.out.println("a = " + a);
System.out.println("b = " + b);
b--;
}
}
}

• Comma (separator) is used while initializing multiple loop
control variables.
Example 2:
class var21
{
public static void main(String arr[]) {
int x, y;
for(x=0, y=5; x<=y; x++, y--) {
System.out.println("x= " + x);
System.out.println(“y = " + y);
}
}
}
• Initialization and iteration can be moved out from for loop.

Example 3:
class Loopchk
{
public static void main(String arr[])
{
for(int i=1, j=5; i>0 && j>2; i++, j--)
System.out.println("i is: "+ i + "and j is: "+j);
}
}

For-Each Version of the for Loop
• Beginning with JDK 5, a second form of for was
defined that implements a “for-each” style loop.
• For-each is also referred to as the enhanced for loop.
• Designed to cycle through a collection of objects,
such as an array, in strictly sequential fashion, from
start to end.

for (type itr-var : collection) statement-block
• type specifies the type.
• itr-var specifies the name of an iteration variable that will
receive the elements from a collection, one at a time, from
beginning to end.
• The collection being cycled through is specified by
collection.
• With each iteration of the loop, the next element in the
collection is retrieved and stored in itr-var.
• The loop repeats until all elements in the collection have
been obtained.

class ForEach
{
{
int num[] = { 1, 2, 3, 4, 5 };
int sum = 0;
for(int i : num)
{
System.out.println("Value is: " + i);
sum += i;
}
System.out.println("Sum is: " + sum);
}
}

Iterating Over Multidimensional Arrays
class ForEachMArray {
int sum = 0;
int num[][] = new int[3][5];
// give num some values
for(int i = 0; i < 3; i++)
for(int j=0; j < 5; j++)
num[i][j] = (i+1)*(j+1);
// use for-each for to display and sum the values
for(int x[] : num) {
for(int y : x) {
System.out.println("Value is: " + y);
sum += y;
}
}
System.out.println("Summation: " + sum);
}
}

Nested Loops
class NestedLoop
{
{
int i, j;
for(i=0; i<10; i++)
{
for(j=i; j<10; j++)
System.out.print(“* ”);
System.out.println( );
}
}
} Ravi Kant Sahu, Asst. Professor @ Lovely Professional University, Punjab (India)

05. Control Structures.ppt

Recommended

More Related Content

Similar to 05. Control Structures.ppt (20)

Recently uploaded (20)

05. Control Structures.ppt

Editor's Notes