Control Flow Statements
The statements inside your source files are generally executed from top to bottom, in the order that they appear.
Control flow statements,
however, break up the flow of execution by employing decision making, looping, and branching, enabling your program to
conditionally execute
particular blocks of code. This section describes
the decision-making statements (
if-then,
if-then-else,
switch),
the looping statements (
for,
while,
do-while), and the branching statements (
break,
continue,
return) supported by the Java programming language.
The if-then and if-then-else Statements
The if-then Statement
The if-then statement is the most basic of
all the control flow statements. It tells your program to execute a certain
section of code only if a particular test evaluates to true.
For example, the Bicycle class could allow the brakes to
decrease the bicycle's speed only if the bicycle is already in motion. One possible
implementation of the applyBrakes method could be as follows:
void applyBrakes(){
if (isMoving){ // the "if" clause: bicycle must be moving
currentSpeed--; // the "then" clause: decrease current speed
}
}
If this test evaluates to false (meaning that the bicycle is not in motion),
control jumps to the end of the if-then statement.
In addition, the opening and closing braces are optional, provided
that the "then" clause contains only one statement:
void applyBrakes(){
if (isMoving) currentSpeed--; // same as above, but without braces
}
Deciding when to omit the braces is a matter of personal taste.
Omitting them can make the code more brittle. If a second statement
is later added to the "then" clause, a common mistake would be forgetting
to add the newly required braces. The compiler cannot catch this sort
of error; you'll just get the wrong results.
The if-then-else Statement
The if-then-else statement provides a secondary path of execution when an
"if" clause evaluates to false. You could use an if-then-else
statement in the applyBrakes method to take some action if the brakes are applied
when the bicycle is not in motion. In this case, the action is to simply print an error message
stating that the bicycle has already stopped.
void applyBrakes(){
if (isMoving) {
currentSpeed--;
} else {
System.err.println("The bicycle has already stopped!");
}
}
The following program,
IfElseDemo, assigns a grade based on the
value of a test score: an A for a score of 90% or above, a B for
a score of 80% or above, and so on.
class IfElseDemo {
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade = " + grade);
}
}
The output from the program is:
Grade = C
You may have noticed that the value of testscore can satisfy more than
one expression in the compound statement: 76 >= 70 and
76 >= 60. However,
once a condition is satisfied, the
appropriate statements are executed (grade = 'C';) and
the remaining conditions are not evaluated.
The switch Statement
Unlike if-then and if-then-else, the switch statement allows for any number of
possible execution paths. A switch works with the
byte, short, char, and int primitive data types.
It also works with enumerated types (discussed in
Classes and Inheritance)
and a few special classes that "wrap" certain primitive types:
Character,
Byte,
Short,
and
Integer
(discussed in
Simple Data Objects
).
The following program,
SwitchDemo,
declares an int named month whose value represents
a month out of the year.
The program displays the name of the month, based on the value of month, using the switch
statement.
class SwitchDemo {
public static void main(String[] args) {
int month = 8;
switch (month) {
case 1: System.out.println("January"); break;
case 2: System.out.println("February"); break;
case 3: System.out.println("March"); break;
case 4: System.out.println("April"); break;
case 5: System.out.println("May"); break;
case 6: System.out.println("June"); break;
case 7: System.out.println("July"); break;
case 8: System.out.println("August"); break;
case 9: System.out.println("September"); break;
case 10: System.out.println("October"); break;
case 11: System.out.println("November"); break;
case 12: System.out.println("December"); break;
default: System.out.println("Invalid month.");break;
}
}
}
In this case, "August" is printed to standard output.
The body of a switch statement is known as a switch block. Any statement immediately contained by the
switch block may be labeled with one or more case or default labels.
The switch statement evaluates its expression
and executes the appropriate case.
Of course, you could also implement the same thing with
if-then-else statements:
int month = 8;
if (month == 1) {
System.out.println("January");
} else if (month == 2) {
System.out.println("February");
}
. . . // and so on
Deciding whether to use if-then-else statements or a switch statement is sometimes
a judgment call. You can decide which one to use based on readability and other factors.
An if-then-else statement can be used to make decisions based on ranges of values or conditions,
whereas a switch statement can make decisions based only on a single integer or
enumerated value.
Another point of interest is the break statement after each case.
Each break statement terminates the enclosing switch statement.
Control flow continues with the first statement following the switch block.
The break statements are necessary because without them, case
statements fall through; that is, without an explicit break, control will flow
sequentially through subsequent case statements. The following program,
SwitchDemo2,
illustrates why it might be useful to have case statements fall through:
class SwitchDemo2 {
public static void main(String[] args) {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDays = 30;
break;
case 2:
if ( ((year % 4 == 0) && !(year % 100 == 0))
|| (year % 400 == 0) )
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = " + numDays);
}
}
This is the output from the program.
Number of Days = 29
Technically, the final break is not required because flow would fall out of
the switch statement anyway. However, we recommend using a break so that
modifying the code is easier and less error-prone. The default section handles
all values that aren't explicitly handled by one
of the case sections.
The while and do-while Statements
The while statement continually executes a block of statements
while a particular condition is true.
Its syntax can be expressed as:
while (expression) {
statement(s)
}
The while statement evaluates expression, which must return a
boolean value. If the expression evaluates to true, the while
statement executes the statement(s) in the while block. The while
statement continues testing the expression and executing its block until the expression
evaluates to false. Using the while statement to print the values
from 1 through 10 can be accomplished as in the following
WhileDemo
program:
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
You can implement an infinite loop using the while statement
as follows:
while (true){
// your code goes here
}
The Java programming language also provides a do-while
statement, which can be expressed as follows:
do {
statement(s)
} while (expression);
The difference between do-while and while is
that do-while evaluates its expression at the bottom of the loop
instead of the top.
Therefore, the statements within the do block are always executed
at least once, as shown in the following
DoWhileDemo
program:
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " + count);
count++;
} while (count <= 11);
}
}
The for Statement
The for statement provides a compact way to iterate over a range of values. Programmers often
refer to it as the "for loop" because of the way in which it repeatedly loops until a particular
condition is satisfied. The general form of the for statement can be expressed as follows:
for (initialization; termination; increment) {
statement(s)
}
When using this version of the for statement, keep in mind that:
- The initialization expression initializes the
loop; it's executed once, as the loop begins.
- When the termination expression evaluates to
false, the loop terminates.
- The increment expression is invoked after each
iteration through the loop; it is perfectly acceptable for this expression
to increment or decrement a value.
The following program,
ForDemo, uses the general form of the for statement to
print the numbers 1 through 10 to standard output:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
}
}
The output of this program is:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Notice how the code declares a variable within the initialization
expression. The scope of this variable extends from its
declaration to the end of the block governed by the for statement, so it can be
used in the termination and increment expressions as well. If the variable that controls
a for statement is not needed outside of the loop, it's best to declare the
variable in the initialization expression. The names i, j, and k
are often used to control for loops; declaring them within the
initialization expression limits their life span and reduces errors.
The three expressions of the for loop are optional; an infinite
loop can be created as follows:
for ( ; ; ) { // infinite loop
// your code goes here
}
The for statement also has another form designed for iteration through
Collections
and
arrays
This form is sometimes referred to as the enhanced for statement, and can be used to make
your loops more compact and easy to read. To demonstrate, consider the following array, which holds the numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
The following program,
EnhancedForDemo, uses the enhanced for to loop through the array:
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}
In this example, the variable item holds the current value from the
numbers array. The output from this program is the same as before:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
The for Statement
The for statement provides a compact way to iterate over a range of values. Programmers often
refer to it as the "for loop" because of the way in which it repeatedly loops until a particular
condition is satisfied. The general form of the for statement can be expressed as follows:
for (initialization; termination; increment) {
statement(s)
}
When using this version of the for statement, keep in mind that:
- The initialization expression initializes the
loop; it's executed once, as the loop begins.
- When the termination expression evaluates to
false, the loop terminates.
- The increment expression is invoked after each
iteration through the loop; it is perfectly acceptable for this expression
to increment or decrement a value.
The following program,
ForDemo, uses the general form of the for statement to
print the numbers 1 through 10 to standard output:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
}
}
The output of this program is:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Notice how the code declares a variable within the initialization
expression. The scope of this variable extends from its
declaration to the end of the block governed by the for statement, so it can be
used in the termination and increment expressions as well. If the variable that controls
a for statement is not needed outside of the loop, it's best to declare the
variable in the initialization expression. The names i, j, and k
are often used to control for loops; declaring them within the
initialization expression limits their life span and reduces errors.
The three expressions of the for loop are optional; an infinite
loop can be created as follows:
for ( ; ; ) { // infinite loop
// your code goes here
}
The for statement also has another form designed for iteration through
Collections
and
arrays
This form is sometimes referred to as the enhanced for statement, and can be used to make
your loops more compact and easy to read. To demonstrate, consider the following array, which holds the numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
The following program,
EnhancedForDemo, uses the enhanced for to loop through the array:
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}
In this example, the variable item holds the current value from the
numbers array. The output from this program is the same as before:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
We recommend using this form of the for statement instead of
the general form whenever possible.
Count is: 10
We recommend using this form of the for statement instead of
the general form whenever possible.
