Posted on: July 27, 2006 at 12:00 AM
Java: Summary - Statements
Each control statements is one logical statement, which often encloses a block of statements in curly braces {}. The examples assume the block contains more than one statement.
The effect of the switch statement is to choose some statements to execute depending on the integer value of an expression.
The same effect can be achieved with a series of cascading if statements, but in some cases the switch statement is easier to read, and in a some compilers it can produce more efficient code.
The break statement exits from the switch statement.
If there is no break at the end of a case, execution continues in the next case and this is almost always an error.
In the following example code we will show you how to use the if else statements.
The if else statement can be used in following ways:
a) if ..else
b) if .. elseif .. else
c) if .. elseif .. elsif .. elsif .. else
The switch statement can be used in following ways
a) switch (expression)
b) case a:
c) case b:
d) defualt:
In the following example code we will show you how to use the if statements.
Another example of switch statement also shows how to use the switch statements correctly.
Indenting is essential. Four spaces is most common.
| Selection (if, switch) |
if Statement
//----- if statement with a true clause
if (expression) {
statements // do these if expression is true
}
//----- if statement with true and false clause
if (expression) {
statements // do these if expression is true
} else {
statements // do these if expression is false
}
//----- if statements with many parallel tests
if (expression1) {
statements // do these if expression1 is true
} else if (expression2) {
statements // do these if expression2 is true
} else if (expression3) {
statements // do these if expression3 is true
. . .
} else {
statements // do these no expression was true
}
|
switch Statement
switch (expr) {
case c1:
statements // do these if expr == c1
break;
case c2:
statements // do these if expr == c2
break;
case c2:
case c3:
case c4: // Cases can simply fall thru.
statements // do these if expr == any of c's
break;
. . .
default:
statements // do these if expr != any above
}
Loop Statements |
whileThe while statement tests the expression. If the expression evaluates to true, it executes the body of the while. If it is false, execution continues with the statement after the while body. Each time after the body is executed, execution starts with the test again. This continues until the expression is false or some other statement (break or return) stops the loop.
while (testExpression) {
statements
}
Other loop controlsAll loop statements can be labeled, so thatbreak and
continue can be used from any nesting depth.
break; //exit innermost loop or switch break label; //exit from loop label continue; //start next loop iteration continue label; //start next loop labelPut label followed by colon at front of loop.
outer: for (. . .) {
. . .
continue outer;
|
Other Flow Control Statements |
Method Returnreturn; //no value for void method return expr; //method value to return Simple
|
for
Many loop have an initialization before the loop, and some "increment" before the next loop. The for loop is the standard way of combining these parts.
for (initialStmt; testExpr; incrementStmt) {
statements
}
This is the same as (except continue will increment):
initialStmt;
while (testExpr) {
statements
incrementStmt
}
do
This is the least used of the loop statements, but sometimes a loop that executes one time before testing is used.
do {
statements
} while (testExpression);
Multiple catch clauses and finally clause
Executes first catch clause that specifies the exception class or a super class.
The finally clause is always executed (regardless of whethere
there was an exception or not) so resources can be cleaned up (eg, closing a file).
try {
. . . // statements that might cause exceptions
} catch (exception-type x) {
. . . // statements to handle exception
} catch (exception-type x) {
. . . // statements to handle exception
} finally (exception-type x) {
. . . // statements that will always be exectuted, exception or not.
}