https://genuinenotes.

com
Unit-5/ Java Programming - I

Unit-5: Control Statements

 A programming language uses control statements to cause the flow of execution to
advance and branch based on changes to the state of a program.
 Java’s program control statements can be put into the following categories: selection,
iteration, and jump.
 Selection statements allow your program to choose different paths of execution based
upon the outcome of an expression or the state of a variable.
 Iteration statements enable program execution to repeat one or more statements (that is,
iteration statements form loops).
 Jump statements allow your program to execute in a nonlinear fashion.

Java’s Selection Statements

 Java supports two selection statements: if and switch. These statements allow us to
control the flow of our program’s execution based upon conditions known only during
run time.
The if statement
 The if statement is Java’s conditional branch statement. It can be used to route program
execution through two different paths. Here is the general form of the if statement:
if (condition) statement1;
else statement2;
Here, each statement may be a single statement or a compound statement enclosed in
curly braces (that is, a block). The condition is any expression that returns a boolean
value. The else clause is optional.
 The if works like this: If the condition is true, then statement1 is executed. Otherwise,
statement2 (if it exists) is executed. In no case will both statements be executed.
 Most often, the expression used to control the if will involve the relational operators.
However, this is not technically necessary. It is possible to control the if using a single
boolean variable, as shown in this code fragment:

 Only one statement can appear directly after the if or the else. If you wan to include more
statements, you’ll need to create a block.
The Nested ifs
 A nested if is an if statement that is the target of another if or else. Nested ifs are very
common in programming. When you nest ifs, the main thing to remember is that an else

1 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

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. Here is an example:

Example:

//Java Program to demonstrate the use of Nested If Statement.

public class JavaNestedIfExample {
public static void main(String[] args) {
//Creating two variables for age and weight
int age=20;
int weight=80;
//applying condition on age and weight
if(age>=18){
if(weight>50){
System.out.println("You are eligible to donate blood");
}
}
}}

2 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

The if-else-if Ladder

A common programming construct that is based upon a sequence of nested ifs is the if-elseif
ladder. It looks like this:

The if statements are executed from the top down. As soon as one of the conditions controlling
the if is true, the statement associated with that if is executed, and the rest of the ladder is
bypassed. If none of the conditions is true, then the final else statement will be executed. The
final else acts as a default condition; that is, if all other conditional tests fail, then the last else
statement is performed. If there is no final else and all other conditions are false, then no action
will take place.
public class IfElseIfExample {

public static void main(String args[]){

int num=1234;
if(num <100 && num>=10) {
System.out.println("Its a two digit number");
}
else if(num <1000 && num>=100) {
System.out.println("Its a three digit number");
}
else if(num <10000 && num>=1000) {
System.out.println("Its a four digit number");
}
else if(num <100000 && num>=10000) {
System.out.println("Its a five digit number");
}
else {
System.out.println("number is not between 1 & 99999");
}
}
}

3 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

The switch statement

 The switch statement is Java’s multiway branch statement. It provides an easy way to
dispatch execution to different parts of your code based on the value of an expression. As
such, it often provides a better alternative than a large series of if-else-if statements. Here
is the general form of a switch statement:

Here expression can be of type byte, short, int, char, enumeration or String
Each value specified in the case statements must be a unique constant expression (such as
a literal value). Duplicate case values are not allowed. The type of each value must be
compatible with the type of expression.
 The switch statement works like this: The value of the expression is compared with each
of the 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. However, 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. This has the effect of “jumping out” of the switch.
 The break statement is optional. If you omit the break, execution will continue on into
the next case. It is sometimes desirable to have multiple cases without break statements
between them.

4 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Example:
class Day {
public static void main(String[] args) {

int week = 4;
String day;

switch (week) {
case 1:
day = "Sunday";
break;
case 2:
day = "Monday";
break;
case 3:
day = "Tuesday";
break;
case 4:
day = "Wednesday";
break;
case 5:
day = "Thursday";
break;
case 6:
day = "Friday";
break;
case 7:
day = "Saturday";
break;
default:
day = "Invalid day";
break;
}
System.out.println(day);
}
}

Nested switch Statements

You can use a switch as part of the statement sequence of an outer switch. This is called a nested
switch. Since a switch statement defines its own block, no conflicts arise between the case
constants in the inner switch and those in the outer switch.
Example:

5 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

public class Main {

public static void main(String[] args) {

int i = 0;
switch (i) {
case 0:
int j = 1;
switch (j) {
case 0:
System.out.println("i is 0, j is 0");
break;
case 1:
System.out.println("i is 0, j is 1");
break;
default:
System.out.println("nested default case!!");
}
break;
default:
System.out.println("No matching case found!!");
}
}
}

Note:
 The switch differs from the if in that 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.
 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.
 A switch statement is usually more efficient than a set of nested ifs.

6 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Iteration Statements
Java’s iteration statements are for, while, and do-while. These statements create what we
commonly call loops. As you probably know, a loop repeatedly executes the same set of
instructions until a termination condition is met.
The while loop
 The while loop is Java’s most fundamental loop statement. It repeats a statement or block
while its controlling expression is true. Here is its general form:

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. The curly braces are unnecessary
if only a single statement is being repeated.
 Since the while loop evaluates its conditional expression at the top of the loop, the body
of the loop will not execute even once if the condition is false to begin with.
Example:
class WhileLoopExample {
public static void main(String args[]){
int i=10;
while(i>1){
System.out.println(i);
i--;
}
}
}

 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.
The following program is an example for this fact.

7 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

The do-while loop

As you just saw, if the conditional expression controlling a while loop is initially false, then the
body of the loop will not be executed at all. However, sometimes it is desirable to execute the
body of a loop at least once, even if the conditional expression is false to begin with. In other
words, there are times when you would like to test the termination expression at the end of the
loop rather than at the beginning. Fortunately, Java supplies a loop that does just that: the do-
while.
 The do-while loop always executes its body at least once, because its conditional
expression is at the bottom of the loop. Its general form is

 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. As with all of Java’s loops, condition must be a Boolean expression.
Example:
class DoWhileLoopExample {
public static void main(String args[]){
int arr[]={2,11,45,9};
//i starts with 0 as array index starts with 0
int i=0;
do{
System.out.println(arr[i]);
i++;
}while(i<4);
}
}

8 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

The for loop

Beginning with JDK 5, there are two forms of the for loop. The first is the traditional form that
has been in use since the original version of Java. The second is the newer “for-each” form.
 Here is the general form of the traditional for statement:

for(initialization; condition; iteration){

//body
}
 If only one statement is being repeated, there is no need for the curly braces.
 The for loop operates as follows. When the loop first starts, the initialization portion of
the loop is executed. Generally, this is an expression that sets the value of the loop
control variable, which acts as a counter that controls the loop. It is important to
understand that the initialization expression is executed only once. Next, condition is
evaluated. This must be a Boolean expression. It usually tests the loop control variable
against a target value. 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. This is
usually an expression that increments or decrements the loop control variable. The loop
then iterates, first evaluating the conditional expression, then executing the body of the
loop, and then executing the iteration expression with each pass. This process repeats
until the controlling expression is false.

Example:
public class ForLoopExample {
public static void main(String args[]){
for(int i=1; i<=10; i++){
System.out.println("7 * "+i+" = "+ 7*i);
}
}
}

9 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Some for Loop Variations

The for loop supports a number of variations that increase its power and applicability. The reason
it is so flexible is that its three parts—the initialization, the conditional test, and the iteration—do
not need to be used for only those purposes. In fact, the three sections of the for can be used for
any purpose you desire
 One of the most common variations involves the conditional expression. Specifically, this
expression does not need to test the loop control variable against some target value. In
fact, the condition controlling the for can be any Boolean expression. For example,
consider the following fragment:

In this example, the for loop continues to run until the boolean variable done is set to true. It
does not test the value of i.
 Here is another interesting for loop variation. Either the initialization or the iteration
expression or both may be absent, as in this next program:

Here, the initialization and iteration expressions have been moved out of the for. Thus, parts of
the for are empty. While this is of no value in this simple example—indeed, it would be
considered quite poor style—there can be times when this type of approach makes sense. For
example, if the initial condition is set through a complex expression elsewhere in the program or
if the loop control variable changes in a nonsequential manner determined by actions that occur
within the body of the loop, it may be appropriate to leave these parts of the for empty.

10 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

 Here is one more for loop variation. You can intentionally create an infinite loop (a loop
that never terminates) if you leave all three parts of the for empty. For example:

This loop will run forever because there is no condition under which it will terminate. Although
there are some programs, such as operating system command processors,that require an infinite
loop, most “infinite loops” are really just loops with special termination requirements.

NOTE: Following picture is a summary of while,do-while and for loops

11 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Java For Loop vs While Loop vs Do While Loop

Comparison for loop while loop do while loop
Introduction The Java for loop is a The Java while The Java do while
control flow statement loop is a control loop is a control
that iterates a part of flow statement flow statement
the programs multiple that executes a that executes a
times. part of the part of the
programs programs at least
repeatedly on the once and the
basis of given further execution
boolean condition. depends upon the
given boolean
condition.
When to use If the number of If the number of If the number of
iteration is fixed, it is iteration is not iteration is not
recommended to use fixed, it is fixed and you must
for loop. recommended to have to execute
use while loop. the loop at least
once, it is
recommended to
use the do-while
loop.
Syntax for(init;condition; while(condition) do{
incr/decr){ { //code to be
// code to be //code to be //executed
//executed //executed }while(condition
} } );

Example //for loop //while loop //do-while loop

for(int int i=1; int i=1;
i=1;i<=10;i++){ while(i<=10){ do{
System.out.println( System.out.print System.out.print
i); ln(i); ln(i);
} i++; i++;
} }while(i<=10);

12 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Syntax for for(;;){ while(true){ do{

infinite loop //code to be executed //code to be //code to be
} //executed //executed
} }while(true);

The 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.
 A for-each style loop is designed to cycle through a collection of objects, such as an
array, in strictly sequential fashion, from start to finish. Unlike some languages, such as
C#, that implement a for-each loop by using the keyword foreach, Java adds the for-each
capability by enhancing the for statement. The advantage of this approach is that no new
keyword is required, and no preexisting code is broken.
 The for-each style of for is also referred to as the enhanced for loop.
 The general form of the for-each version of the for is shown here:
for(type itr-var : collection) statement-block
Here, type specifies the type and 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. There are various types of
collections that can be used with the for, but the only type used in this chapter is the
array.
 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.
 Because the iteration variable receives values from the collection, type must be the same
as (or compatible with) the elements stored in the collection. Thus, when iterating over
arrays, type must be compatible with the element type of the array.
 Although the for-each for loop iterates until all elements in an array have been examined,
it is possible to terminate the loop early by using a break statement

13 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

The following program uses a traditional for loop to compute the sum of the values in an array:
public class Sum {
public static void main(String[] args){
int numbers[] = {1,2,3,4,5,6,7,8,9,10};
int sum=0;
for(int i =0;i<numbers.length;i++){
sum+=numbers[i];
}
System.out.println("The sum of elements of the array is= "+sum);

}
}

The following program uses for each style loop to compute the sum of elements of an array:
public class ForEachDemo {
public static void main(String[] args){
int numbers[] = {1,2,3,4,5,6,7,8,9,10};
int sum=0;
//using for-each style loop
for(int x: numbers){
sum+=x;
}
System.out.println("The sum of elements of the array is= "+sum);

}
}

14 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

In summary:
 It starts with the keyword for like a normal for-loop.
 Instead of declaring and initializing a loop counter variable, we declare a variable that is
the same type as the base type of the array, followed by a colon, which is then followed
by the array name.
 In the loop body, we can use the loop variable we created rather than using an indexed
array element.
 It’s commonly used to iterate over an array or a Collections class (eg, ArrayList)
Limitations of for-each loop
 For-each loops are not appropriate when we want to modify the array:
 For-each loops do not keep track of index. So we cannot obtain array index using For-
Each loop
 For-each only iterates forward over the array in single steps
Iterating Over Multidimensional Arrays
 The enhanced version of the for also works on multidimensional arrays.
 When using the for-each for to iterate over an array of N dimensions, the objects obtained
will be arrays of N–1 dimensions. For example, in the case of a two dimensional array,
the iteration variable must be a reference to a one-dimensional array
Example:

public class TwoD {

public static void main(String[] args){
int arr[][]= new int[3][5];
int sum=0;
//adding some values to arr
for(int i = 0; i<3;i++){
for(int j =0;j<5;j++){
arr[i][j]=(i+1)*(j+1);
}
}
//using for each loop to display and sum the values
for(int x[]:arr){
for(int y: x){
System.out.println("The element is:"+y);
sum = sum+y;
}
}
System.out.println("Sum is = "+sum);
}
}

15 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Notice how x is declared. It is a reference to a one-dimensional array of integers. This is

necessary because each iteration of the for obtains the next array in arr, beginning with the array
specified by arr[0]. The inner for loop then cycles through each of these arrays, displaying the
values of each element.
Application of the Enhanced for
Since the for-each style for can only cycle through an array sequentially, from start to finish, you
might think that its use is limited, but this is not true. A large number of algorithms require
exactly this mechanism. One of the most common is searching.
Example:

16 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Nested Loops
Like all other programming languages, Java allows loops to be nested. That is, one loop may be
inside another.
public class PatternExample {
public static void main(String[] args){
for(int i = 1;i<5;i++){
for(int j=i;j<5;j++){
System.out.print("+");
}
System.out.println();
}
}
}

Jump Statements
Java supports different jump statements. break, continue are two of them.
Using break
In Java, the break statement has three uses.
1. To terminate a statement sequence in a switch statement.
2. It can be used to exit a loop.
3. It can be used as a “civilized” form of goto.
Using break to Exit a Loop
By using break, you can force immediate termination of a loop, bypassing the conditional
expression and any remaining code in the body of the loop. When a break statement is
encountered inside a loop, the loop is terminated and program control resumes at the next
statement following the loop.
 The break statement can be used with any of Java’s loops, including intentionally infinite
loops.
 The break statement in the inner loop only causes termination of that loop. The outer
loop is unaffected.

17 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

//Java Program to demonstrate the use of break statement

//inside the Java do-while loop.
public class BreakDoWhileExample {
public static void main(String[] args) {
//declaring variable
int i=1;
//do-while loop
do{
if(i==5){
//using break statement
i++;
break;//it will break the loop
}
System.out.println(i);
i++;
}while(i<=10);
}
}

18 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Output:

1
2
3
4

Note: Here are two other points to remember about break. First, more than one break statement
may appear in a loop. However, be careful. Too many break statements have the tendency to
destructure your code. Second, the break that terminates a switch statement affects only that
switch statement and not any enclosing loops.

Using break as a Form of Goto

In addition to its uses with the switch statement and loops, the break statement can also be
employed by itself to provide a “civilized” form of the goto statement. Java does not have a goto
statement because it provides a way to branch in an arbitrary and unstructured manner. This
usually makes goto-ridden code hard to understand and hard to maintain. It also prohibits certain
compiler optimizations. There are, however, a few places where the goto is a valuable and
legitimate construct for flow control. For example, the goto can be useful when you are exiting
from a deeply nested set of loops. To handle such situations, Java defines an expanded form of
the break statement. By using this form of break, you can, for example, break out of one or more
blocks of code. These blocks need not be part of a loop or a switch. They can be any block.
Further, you can specify precisely where execution will resume, because this form of break
works with a label.

19 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

 break gives us the benefits of a goto without its problems.

 The general form of the labeled break statement is shown here:
break label;

 Most often, label is the name of a label that identifies a block of code. This can be a
standalone block of code but it can also be a block that is the target of another statement.
 When this form of break executes, control is transferred out of the named block. The
labeled block must enclose the break statement, but it does not need to be the
immediately enclosing block. This means, for example, that you can use a labeled break
statement to exit from a set of nested blocks. But you cannot use break to transfer control
out of a block that does not enclose the break statement.
To name a block, put a label at the start of it. A label is any valid Java identifier followed by a
colon. Once you have labeled a block, you can then use this label as the target of a break
statement.

Example:

class LabeledBreak {
public static void main(String[] args) {
first:
for( int i = 1; i < 5; i++) {

second:
for(int j = 1; j < 3; j ++ ) {
System.out.println("i = " + i + "; j = " +j);

20 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

if ( i == 2)
break first;
}
}
}
}

Another Example:

Using continue
Sometimes it is useful to force an early iteration of a loop. That is, you might want to continue
running the loop but stop processing the remainder of the code in its body for this particular
iteration. This is, in effect, a goto just past the body of the loop, to the loop’s end. The continue
statement performs such an action. In while and do-while loops, a continue statement causes
control to be transferred directly to the conditional expression that controls the loop. In a for
loop, control goes first to the iteration portion of the for statement and then to the conditional
expression. For all three loops, any intermediate code is bypassed.
 The continue statement is used in loop control structure when you need to jump to the
next iteration of the loop immediately.
 The Java continue statement is used to continue the loop. It continues the current flow of
the program and skips the remaining code at the specified condition.
 In a for loop, the continue keyword causes control to immediately jump to the update
statement.
 In a while loop or do/while loop, control immediately jumps to the Boolean expression.

21 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

 As with the break statement, continue may specify a label to describe which enclosing
loop to continue.

Example:

class Test {
public static void main(String[] args) {

for (int i = 1; i <= 10; ++i) {

if (i > 4 && i < 9) {
continue;
}
System.out.println(i);
}
}
}

22 Collected by Bipin Timalsina

https://genuinenotes.com
https://genuinenotes.com
Unit-5/ Java Programming - I

Output:
1
2
3
4
9
10

//Java Program to illustrate the use of continue statement

//with label inside an inner loop to continue outer loop
public class ContinueExample3 {
public static void main(String[] args) {
aa:
for(int i=1;i<=3;i++){
bb:
for(int j=1;j<=3;j++){
if(i==2&&j==2){
//using continue statement with label
continue aa;
}
System.out.println(i+" "+j);
}
}
}
}

Output:
1 1
1 2
1 3
2 1
3 1
3 2
3 3

Good uses of continue are rare. One reason is that Java provides a rich set of loop statements
which fit most applications. However, for those special circumstances in which early iteration is
needed, the continue statement provides a structured way to accomplish it.

23 Collected by Bipin Timalsina

https://genuinenotes.com