{"id":3443,"date":"2019-06-20T11:42:17","date_gmt":"2019-06-20T11:42:17","guid":{"rendered":"http:\/\/softlect.in\/?p=3443"},"modified":"2019-06-20T11:58:57","modified_gmt":"2019-06-20T11:58:57","slug":"java-control-statements","status":"publish","type":"post","link":"http:\/\/softlect.com\/index.php\/java-control-statements\/","title":{"rendered":"Java Control Statements"},"content":{"rendered":"

<\/a>Control Statements<\/strong><\/h1>\n

 <\/p>\n

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

\u00a0<\/em><\/p>\n

<\/a>Java\u2019s Selection Statements<\/strong><\/h2>\n

Java supports two selection statements: if <\/strong>and switch<\/strong>. These statements allow you to control the flow of your program\u2019s execution based upon conditions known only during run time.<\/p>\n

<\/a>if<\/h3>\n

The if <\/strong>statement is Java\u2019s conditional branch statement. It can be used to route program execution through two different paths. Here is the general form of the if <\/strong>statement:<\/p>\n

 <\/p>\n

if (condition<\/em>)<\/p>\n

statement1<\/em>;<\/p>\n

else<\/p>\n

statement2<\/em>;<\/p>\n

 <\/p>\n

Here, each statement <\/em>may be a single statement or a compound statement enclosed in curly braces that is, a block<\/em>. The condition <\/em>is any expression that returns a boolean <\/strong>value. The else <\/strong>clause is optional.<\/p>\n

The if <\/strong>works like this: If the condition <\/em>is true, then statement1 <\/em>is executed. Otherwise, statement2 <\/em>\u00a0is executed. In no case will both statements be executed. For example, consider the following:<\/p>\n

 <\/p>\n

int a, b;<\/p>\n

\/\/ …<\/p>\n

if(a < b) a = 0;<\/p>\n

else b = 0;<\/p>\n

 <\/p>\n

Here, if a <\/strong>is less than b<\/strong>, then a <\/strong>is set to zero. Otherwise, b <\/strong>is set to zero. In no case are they both set to zero. Most often, the expression used to control the if <\/strong>will involve the relational operators. It is possible to control the if <\/strong>using a single boolean <\/strong>variable, as shown in this code fragment:<\/p>\n

 <\/p>\n

boolean dataAvailable;<\/p>\n

\/\/ …<\/p>\n

if (dataAvailable)<\/p>\n

ProcessData();<\/p>\n

else<\/p>\n

waitForMoreData();<\/p>\n

 <\/p>\n

Remember, only one statement can appear directly after the if <\/strong>or the else<\/strong>. If you want to include more statements, you\u2019ll need to create a block, as in this fragment:<\/p>\n

 <\/p>\n

int bytesAvailable;<\/p>\n

\/\/ …<\/p>\n

if (bytesAvailable > 0) {<\/p>\n

ProcessData();<\/p>\n

bytesAvailable -= n;<\/p>\n

} else<\/p>\n

waitForMoreData();<\/p>\n

 <\/p>\n

Here, both statements within the if <\/strong>block will execute if bytesAvailable <\/strong>is greater than zero. For example, consider the following code fragment:<\/p>\n

 <\/p>\n

int bytesAvailable;<\/p>\n

\/\/ …<\/p>\n

if (bytesAvailable > 0) {<\/p>\n

ProcessData();<\/p>\n

bytesAvailable -= n;<\/p>\n

} else<\/p>\n

waitForMoreData();<\/p>\n

bytesAvailable = n;<\/p>\n

 <\/p>\n

It seems clear that the statement bytesAvailable = n; <\/strong>was intended to be executed inside the else <\/strong>clause, because of the indentation level. The preceding example is fixed in the code that follows:<\/p>\n

 <\/p>\n

int bytesAvailable;<\/p>\n

\/\/ …<\/p>\n

if (bytesAvailable > 0) {<\/p>\n

ProcessData();<\/p>\n

bytesAvailable -= n;<\/p>\n

} else {<\/p>\n

waitForMoreData();<\/p>\n

bytesAvailable = n;<\/p>\n

}<\/p>\n

<\/a>Nested ifs<\/h3>\n

A nested <\/em>if <\/strong>is an if <\/strong>statement that is inside another if <\/strong>or else<\/strong>. Nested if<\/strong>s are very common in programming. When you nest if<\/strong>s, the main thing to remember is that an else <\/strong>statement always refers to the nearest if <\/strong>statement. Here is an example:<\/p>\n

 <\/p>\n

if(i == 10) {<\/p>\n

if(j < 20) a = b;<\/p>\n

if(k > 100) c = d; \/\/ this if is<\/p>\n

else a = c; \/\/ associated with this else<\/p>\n

}<\/p>\n

else a = d; \/\/ this else refers to if(i == 10)<\/p>\n

 <\/p>\n

As the comments indicate, the final else <\/strong>is not associated with if(j<20)<\/strong>, because it is not in the same block even though it is the nearest if <\/strong>without an else<\/strong>. Rather, the final else <\/strong>is associated with if(i==10)<\/strong>. The inner else <\/strong>refers to if(k>100)<\/strong>, because it is the closest if <\/strong>within the same block.<\/p>\n

<\/a>The if-else-if Ladder<\/h3>\n

A common programming construct that is based upon a sequence of nested if<\/strong>s is the if-else-if <\/em><\/strong>ladder<\/em>. It looks like this:<\/p>\n

 <\/p>\n

if(condition<\/em>)<\/p>\n

statement;<\/em><\/p>\n

else if(condition<\/em>)<\/p>\n

statement<\/em>;<\/p>\n

else if(condition<\/em>)<\/p>\n

statement<\/em>;<\/p>\n

…<\/p>\n

else<\/p>\n

statement<\/em>;<\/p>\n

 <\/p>\n

The if <\/strong>statements are executed from the top down. As soon as one of the conditions controlling the if <\/strong>is true<\/strong>, the statement associated with that if <\/strong>is executed, and the rest of the ladder is skiped. If none of the conditions is true, then the final else <\/strong>statement will be executed. The final else <\/strong>acts as a default condition; that is, if all other conditional tests fail, then the last else <\/strong>statement is performed. If there is no final else <\/strong>and all other conditions are false<\/strong>, then no action will take place. Here is a program that uses an if-else-if <\/strong>ladder to determine which season a particular month is in.<\/p>\n

 <\/p>\n

\/\/ Demonstrate if-else-if statements.<\/p>\n

class IfElse {<\/p>\n

public static void main(String args[]) {<\/p>\n

int month = 4; \/\/ April<\/p>\n

String season;<\/p>\n

if(month == 12 || month == 1 || month == 2)<\/p>\n

season = “Winter”;<\/p>\n

else if(month == 3 || month == 4 || month == 5)<\/p>\n

season = “Spring”;<\/p>\n

else if(month == 6 || month == 7 || month == 8)<\/p>\n

season = “Summer”;<\/p>\n

else if(month == 9 || month == 10 || month == 11)<\/p>\n

season = “Autumn”;<\/p>\n

else<\/p>\n

season = “Bogus Month”;<\/p>\n

System.out.println(“April is in the ” + season + “.”);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

Here is the output produced by the program:<\/p>\n

April is in the Spring.<\/p>\n

<\/a>switch<\/h3>\n

The switch <\/strong>statement is Java\u2019s multiway branch statement. It provides an easy way to send 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 <\/strong>statements. Here is the general form of a switch <\/strong>statement:<\/p>\n

 <\/p>\n

switch (expression<\/em>) {<\/p>\n

case value1<\/em>:<\/p>\n

\/\/ statement sequence<\/p>\n

break;<\/p>\n

case value2<\/em>:<\/p>\n

\/\/ statement sequence<\/p>\n

break;<\/p>\n

…<\/p>\n

case valueN<\/em>:<\/p>\n

\/\/ statement sequence<\/p>\n

break;<\/p>\n

default:<\/p>\n

\/\/ default statement sequence<\/p>\n

}<\/p>\n

 <\/p>\n

The expression <\/em>must be of type byte<\/strong>, short<\/strong>, int<\/strong>, or char<\/strong>; each of the values <\/em>specified in the case <\/strong>statements must be of a type compatible with the expression. Each case <\/strong>value must be a unique literal that is, it must be a constant, not a variable. Duplicate case <\/strong>values are not allowed. The switch <\/strong>statement works like this: The value of the expression is compared with each of the literal values in the case <\/strong>statements. If a match is found, the code sequence following that case <\/strong>statement is executed. If none of the constants matches the value of the expression, then the default <\/strong>statement is executed. However, the default <\/strong>statement is optional. If no case <\/strong>matches and no default <\/strong>is present, then no further action is taken. The break <\/strong>statement is used inside the switch <\/strong>to terminate a statement sequence. When a break <\/strong>statement is encountered, execution branches to the first line of code that follows the entire switch <\/strong>statement. This has the effect of \u201cjumping out\u201d of the switch<\/strong>. Here is a simple example that uses a switch <\/strong>statement:<\/p>\n

 <\/p>\n

\/\/ A simple example of the switch.<\/p>\n

class SampleSwitch {<\/p>\n

public static void main(String args[]) {<\/p>\n

for(int i=0; i<6; i++)<\/p>\n

switch(i) {<\/p>\n

case 0:<\/p>\n

System.out.println(“i is zero.”);<\/p>\n

break;<\/p>\n

case 1:<\/p>\n

System.out.println(“i is one.”);<\/p>\n

break;<\/p>\n

case 2:<\/p>\n

System.out.println(“i is two.”);<\/p>\n

break;<\/p>\n

case 3:<\/p>\n

System.out.println(“i is three.”);<\/p>\n

break;<\/p>\n

default:<\/p>\n

System.out.println(“i is greater than 3.”);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

The output produced by this program is shown here:<\/p>\n

i is zero.<\/p>\n

i is one.<\/p>\n

i is two.<\/p>\n

i is three.<\/p>\n

i is greater than 3.<\/p>\n

i is greater than 3.<\/p>\n

 <\/p>\n

As you can see, each time through the loop, the statements associated with the case <\/strong>constant that matches i <\/strong>are executed. All others are bypassed. After i <\/strong>is greater than 3, no case <\/strong>statements match, so the default <\/strong>statement is executed. The break <\/strong>statement is optional. If you omit the break<\/strong>, execution will continue on into the next case<\/strong>. It is sometimes desirable to have multiple case<\/strong>s without break <\/strong>statements between them. For example, consider the following program:<\/p>\n

 <\/p>\n

\/\/ In a switch, break statements are optional.<\/p>\n

class MissingBreak {<\/p>\n

public static void main(String args[]) {<\/p>\n

for(int i=0; i<12; i++)<\/p>\n

switch(i) {<\/p>\n

case 0:<\/p>\n

case 1:<\/p>\n

case 2:<\/p>\n

case 3:<\/p>\n

case 4:<\/p>\n

System.out.println(“i is less than 5”);<\/p>\n

break;<\/p>\n

case 5:<\/p>\n

case 6:<\/p>\n

case 7:<\/p>\n

case 8:<\/p>\n

case 9:<\/p>\n

System.out.println(“i is less than 10”);<\/p>\n

break;<\/p>\n

default:<\/p>\n

System.out.println(“i is 10 or more”);<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

This program generates the following output:<\/p>\n

i is less than 5<\/p>\n

i is less than 5<\/p>\n

i is less than 5<\/p>\n

i is less than 5<\/p>\n

i is less than 5<\/p>\n

i is less than 10<\/p>\n

i is less than 10<\/p>\n

i is less than 10<\/p>\n

i is less than 10<\/p>\n

i is less than 10<\/p>\n

i is 10 or more<\/p>\n

i is 10 or more<\/p>\n

 <\/p>\n

As you can see, execution falls through each case <\/strong>until a break <\/strong>statement or the end of the switch<\/strong> is reached. omitting the break <\/strong>statement has many practical applications in real programs. The example below uses a switch <\/strong>to provide a more efficient implementation.<\/p>\n

 <\/p>\n

\/\/ An improved version of the season program.<\/p>\n

class Switch {<\/p>\n

public static void main(String args[]) {<\/p>\n

int month = 4;<\/p>\n

String season;<\/p>\n

switch (month) {<\/p>\n

case 12:<\/p>\n

case 1:<\/p>\n

case 2:<\/p>\n

season = “Winter”;<\/p>\n

break;<\/p>\n

case 3:<\/p>\n

case 4:<\/p>\n

case 5:<\/p>\n

season = “Spring”;<\/p>\n

break;<\/p>\n

case 6:<\/p>\n

case 7:<\/p>\n

case 8:<\/p>\n

season = “Summer”;<\/p>\n

break;<\/p>\n

case 9:<\/p>\n

case 10:<\/p>\n

case 11:<\/p>\n

season = “Autumn”;<\/p>\n

break;<\/p>\n

default:<\/p>\n

season = “Bogus Month”;<\/p>\n

}<\/p>\n

System.out.println(“April is in the ” + season + “.”);<\/p>\n

}<\/p>\n

}<\/p>\n

<\/a>Nested switch Statements<\/h3>\n

You can use a switch <\/strong>as part of the statement sequence of an outer switch<\/strong>. This is called a nested <\/em>switch<\/strong>. Since a switch <\/strong>statement defines its own block, no conflicts arise between the case <\/strong>constants in the inner switch <\/strong>and those in the outer switch<\/strong>. For example, the following fragment is perfectly valid:<\/p>\n

 <\/p>\n

switch(count) {<\/p>\n

case 1:<\/p>\n

switch(target) { \/\/ nested switch<\/p>\n

case 0:<\/p>\n

System.out.println(“target is zero”);<\/p>\n

break;<\/p>\n

case 1: \/\/ no conflicts with outer switch<\/p>\n

System.out.println(“target is one”);<\/p>\n

break;<\/p>\n

}<\/p>\n

break;<\/p>\n

case 2: \/\/ …<\/p>\n

 <\/p>\n

Here, the case 1: <\/strong>statement in the inner switch does not conflict with the case 1: <\/strong>statement in the outer switch. The count <\/strong>variable is only compared with the list of cases at the outer level. If count <\/strong>is 1, then target <\/strong>is compared with the inner list cases. In summary, there are three important features of the switch <\/strong>statement to note:<\/p>\n