java控制语句

Java程序通过控制语句来执行程序流，完成一定的任务。程序流是由若干个语句组成的，语句可以是单一的一条语句，如c=a+b,也可以是用大括号{}括起来的一个复合语句。Java中的控制语句有以下几类：

◇ 分支语句：if-else, switch

◇ 循环语句：while, do-while, for

◇ 与程序转移有关的跳转语句：break, continue, return

◇ 例外处理语句：try-catch-finally, throw

◇ 注释语句：//，/* */， /** */ 

1 分支语句

分支语句提供了一种控制机制，使得程序的执行可以跳过某些语句不执行，而转去执行特定的语句。

1．条件语句 if-else

if(boolean-expression)
　   statement1;
[else statement2;]

（1）布尔表达式boolean-expression是任意一个返回布尔型数据的达式(这比C、C++的限制要严格)。 

（2）每个单一的语句后都必须有分号。 

（3）语句statement1，statement2可以为复合语句，这时要用大括号{}括起。建议对单一的语句也用大括号括起，这样程序的可读性强，而且有利于程序的扩充(可以在其中填加新的语句)。{}外面不加分号。 

（4）else子句是任选的。 

（5）若布尔表达式的值为true，则程序执行statement1，否则执行statement2。 

（6）if-else语句的一种特殊形式为： 

if(expression1){ 
statement1 
}else if(expression2){ 
statement2 
}...... 
}else if(expressionM){ 
statementM 
}else{ 
statementN 
}

else子句不能单独作为语句使用，它必须和if配对使用。else总是与离它最近的if配对。可以通过使用大括号{}来改变配对关系。

【例】最简单的分支结构实现Example1_5.java

public class Example1_5 {
public static void main(String[] args) {
int score = 56;
if(score>60) 
数学及格了"); 
}
     }

【例】简单的双分支结构实现Example1_6.java

public class Example1_6 {
public static void main(String[] args) {
int a = 4 , b = 5 ;
int max;
if(a>b) 
      max=a;
else 
  max=b;
 System.out.println("max=",max);
     }
}

【例】判断某一年是否为闰年。 

闰年的条件是符合下面二者之一：①能被4整除，但不能被100整除;②能被4整除，又能被100整除。 

public class Example1_7{ 
public static void main(String args[]){ 
int year=1989; 
if((year%4==0&&year%100!=0)||(year%400==0)) 
System.out.println(year+"isaleapyear."); 
else 
System.out.println(year+"isnotaleapyear.");
}

2．多分支语句 switch

switch语句根据表达式的值来执行多个操作中的一个，它的般格式如下： 

switch (expression){ 
case value1:statement1; 
break; 
case value2:statement2; 
break; 
………… 
case valueN:statemendN; 
break; 
 [default:defaultStatement;] 
}

（1）表达式expression可以返回任一简单类型的值(如整型、实型、字符型)，多分支语句把表达式返回的值与每个case子句中的值相比。如果匹配成功，则执行该case子句后的语句序列。 

（2）case子句中的值valueI必须是常量，而且所有case子句中的值是不同的。 

（3）default子句是任选的。当表达式的值与任一case子句中的?都不匹配时，程序执行default后面的语句。如果表达式的值与任一case子句中的值都不?配且没有default子句，则程序不作任何操作，而是直接跳出switch语句。 

（4）break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。因为case子句只是起到一个标号的作用，用来查找匹配的入口并从此处开始执行，对后面的case子句不再进行匹配，而是直接执行其后的语句序列，因此该在每个case分支后，要用break来终止后面的case分支语句的执行。在一些特殊情况下，多个不同的case值要执行一组相同的操，这时可以不用break。 

（5）case分支中包括多个执行语句时，可以不用大括号{}括起。 

（6）switch语句的功能可以用if-else来实现，但在某些情况下，使switch语句更简炼，可读性强，而且程序的执行效率提高。 

【例】根据考试成绩的等级打印出百分制分数段。 

public class Example1_8{ 
public static void main(String args[]){ 
System.out.println("\n**firstsituation**"); 
char grade='C';//normaluse 
switch(grade){ 
case 'A':System.out.println(grade+" is 85～100"); break; 
case 'B':System.out.println(grade+" is 70～84"); break; 
case 'C':System.out.println(grade+" is 60～69"); break; 
case 'D':System.out.println(grade+" is ＜60"); 
}
}
}

【例】根据百分制分数的考试成绩打印出等级段。

public class Example1_9 {
public static void main(String[] args) {
System.out.println("\n**firstsituation**"); 
float score=77f;
int grade;
grade = (int )score/10;
switch(grade){ 
case 10:
case  9: System.out.println(score +" is A"); break; 
case  8: System.out.println(score+" is B"); break; 
case  7:
case  6: System.out.println(score+" is C"); break; 
case  5:
case  4:
case  3:
case  2:
case  1:
case  0: System.out.println(score+" is D"); break;
default : System.out.println(" the score is valid\n");
}
     }
}

2 循环语句

循环（loops）语句的作用是反复执行一段代码，直到满足终止循环的条件为止。Java语言中提供的循环语句有：

◇ while语句

◇ do-while语句

◇ for语句

1．while语句

while 语句是Java 最基本的循环语句。当它的控制表达式是真时，while 语句重复执行一个语句或语句块。它的通用格式如下：

while(condition) {
// body of loop 
}

条件condition 可以是任何布尔表达式。只要条件表达式为真，循环体就被执行。当条件condition 为假时，程序控制就传递到循环后面紧跟的语句行。如果只有单个语句需要重复，大括号是不必要的。

【例】用while循环求1~100的和

public class Example1_10 {
public static void main(String[] args) {
int i = 1;
int result = 0;
while (i<=100){
result = result + i;
i++;
}
System.out.println(" the result is "+result);
}
}

因为while 语句在循环一开始就计算条件表达式，若开始时条件为假，则循环体一次也不会执行。例如，下面的程序代码中，对println( ) 的调用从未被执行过：

int a = 10, b = 20; 
while(a > b)
System.out.println(This will not be displayed);

while 循环（或Java 的其他任何循环）的循环体可以为空。这是因为一个空语句（null statement) （仅由一个分号组成的语句）在Java 的语法上是合法的。

【例】分析下面的程序

public class Example1_11 {
public static void main(String[] args) {
int i, j; 
i = 100; 
j = 200; 
// find midpoint between i and j
while( ++i < --j) ; // no body in this loop 
System.out.println("Midpoint is "+i);
}
}

该程序找出变量i和变量j的中间点。它产生的输出如下：

Midpoint is 150 

该程序中的while 循环是这样执行的。值i自增，而值j自减，然后比较这两个值。如果新的值i仍比新的值j小，则进行循环。如果i等于或大于j，则循环停止。在退出循环前，i 将保存原始i和j的中间值（当然，这个程序只有在开始时i比j小的情况下才执行）。正如你看到的，这里不需要循环体。所有的行为都出现在条件表达式自身内部。在专业化的Java 代码中，一些可以由控制表达式本身处理的短循环通常都没有循环体。

2．do-while语句

如果while 循环一开始条件表达式就是假的，那么循环体就根本不被执行。然而，有时需要在开始时条件表达式即使是假的情况下，while 循环至少也要执行一次。换句话说，有时需要在一次循环结束后再测试中止表达式，而不是在循环开始时。Java 就提供了这样的循环：do-while 循环。do-while 循环总是执行它的循环体至少一次，因为它的条件表达式在循环的结尾。它的通用格式如下： 

do {
// body of loop
} while (condition);

do-while 循环总是先执行循环体，然后再计算条件表达式。如果表达式为真，则循环继续。否则，循环结束。对所有的Java 循环都一样，条件condition 必须是一个布尔表达式。

【例】用do…while循环求1~100的和

public class Example1_12 {
public static void main(String[] args) {
int i = 1;
int result = 0;
do {
result = result + i;
i++;
} while (i<=100);
System.out.println(" the result is "+result);
}
}

3．for语句

for 循环的通用格式：

for(initialization; condition; iteration) {
// body
}

for循环的执行过程如下。

第一步，当循环启动时，先执行其初始化部分（initialization）。通常，这是设置循环控制变量值的一个表达式，作为控制循环的计数器，初始化表达式仅被执行一次。

第二步，计算条件condition 的值。条件condition 必须是布尔表达式。它通常将循环控制变量与目标值相比较。如果这个表达式为真，则执行循环体；如果为假，则循环终止。

第三步，执行循环体的反复部分（iteration）。这部分通常是增加或减少循环控制变量的一个表达式。

重复循环，首先计算条件表达式的值，然后执行循环体，接着执行反复表达式。这个过程不断重复直到控制表达式变为假。

◇ 初始化、终止以及迭代部分都可以为空语句(但分号不能省)，三者均为空的时候，相当于一个无限循环。

◇ 在初始化部分和迭代部分可以使用逗号语句，来进行多个操作。逗号语句是用逗号分隔的语句序列。

for( i=0, j=10; i<j; i++, j--){
　　　　……
}

【例】用for循环求1~100的和

public class Example1_13 {
public static void main(String[] args) {
int i, result = 0;
for( i = 0; i<=100; i++)
result = result + i;
System.out.println(" the result is "+result);
}
}

3 循环嵌套

和其他编程语言一样，Java 允许循环嵌套。也就是，一个循环在另一个循环之内。

【例】分析程序中的循环嵌套

// Loops may be nested.
public class Example1_14 {
public static void main(String args[]) {
int i, j; 
for(i=0; i<5; i++ ) {
for(j=i; j<5 j++)
System.out.print("·");
System.out.println();
}
}
}

程序运行结果如下所示：

·····
····
···
··
·


4 跳转语句

Java 支持 3 种跳转语句：break，continue 和return 。这些语句把控制转移到程序的其他部分。

注意：除了这里讨论的跳转语句，Java 还支持另一种能改变程序执行流程的方法：异常处理。异常处理提供了一种结构化的方法，通过该方法可以使你的程序捕获并处理运行时刻错误。它由下列五个关键字来控制：try，catch，throw，throws，和 finally 。实质上，异常处理机制允许程序完成一个非局部的分支跳转。由于异常处理是一个大话题，将在第 10 章专门讨论。

1．break 语句

在Java 中，break语句可有一下作用。

l 在switch语句中，它被用来终止一个语句序列。

l 直接强行退出循环，忽略循环体中的任何其他语句和循环的条件测试。

【例】分析例子

// Using break to exit a loop.
public class Example1_15  {
public static void main(String[] args) {
for(int i=0; i<100; i++) {
if(i == 5) break; // terminate loop if i is 5
System.out.println("i: " + i);
}
System.out.println("Loop complete.");
}
}

该程序产生如下的输出：

i: 0 
i: 1 
i: 2 
i: 3 
i: 4

Loop complete. 

尽管for 循环被设计为从 0执行到99，但是当i等于5时，break语句终止了程序。

在一系列嵌套循环中使用break 语句时，它将仅仅终止最里面的循环。

【例】分析例子

// Using break with nested loops.
public class Example1_16 { 
public static void main(String args[]) {
for(int i=0; i<3; i++) {
System.out.print("Pass " + i + ": ");
for(int j=0; j<100; j++) {
if(j == 10) break; // terminate loop if j is 10
System.out.print(j + " ");
}
System.out.println();
}
System.out.println("Loops complete.");
}
}

该程序运行结果如下：

Pass 0: 0 1 2 3 4 5 6 7 8 9 
Pass 1: 0 1 2 3 4 5 6 7 8 9 
Pass 2: 0 1 2 3 4 5 6 7 8 9

Loops complete. 

从中可以看出，在内部循环中的break语句仅仅终止了该循环，外部的循环不受影响。

关于break ，在这里要记住两点：

l 一个循环中可以有一个以上的break 语句。但要小心，太多的break 语句会破坏你的代码结构。

l switch语句中的break仅仅影响该switch 语句，而不会影响其中的任何循环。

break 不是被设计来提供一种正常的循环终止的方法。循环的条件语句是专门用来终止循环的。只有在某类特殊的情况下，才用break 语句来取消一个循环。

2．continue语句

continue语句只能使用在循环语句内部，功能是跳过该次循环，继续执行下一次循环结构。在while和do-while语句中continue语句跳转到循环条件处开始继续执行，而在for语句中continue语句跳转到迭代语句处开始继续执行。

【例】分析代码

int i = 0; 
while(i < 4){
i++; 
if(i == 2)
continue;
System.out.println(i); 
}

该代码的执行结果是：

1
3
4

) Z; f8 C# }; X在变量i的值等于2时，执行continue语句，则后续未执行完成的循环体将被跳过，而直接进入下一次循环。

5 x* M7 `1 d& O% J在实际的代码中，可以使用continue语句跳过循环中的某些内容。

/ ?$ @) x8 c  [2 K) B/ w和前面介绍的break语句类似，continue语句使用在循环嵌套的内部时，也只是跳过所在循环的结构，如果需要跳过外部的循环，则需要使用标签语句标识对应的循环结构。

【例】分析代码

lable1:
$ l2 T6 T) h4 A6 I' r7 @, Jfor(int i = 0; i < 10; i++){
for(int j = 0; j < 5; j++){
System.out.println(j); 
if(j == 3)
* {$ e) y$ ?! a. @" Kcontinue label1; 
, h# D* Q1 V/}
2 L+ v2 J2 M% ~" U}

这样在执行continue语句时，就不再是跳转到j++语句，而是直接跳转到i++语句

3．返回语句return

return语句从当前方法中退出，返回到调用该方法的语句处，并从紧跟该语句的下一条语句继续程序的执行。返回语句有两种格式：

l return expression ;
l return;