ＪＡＶＡ学习——流程控制

流程控制语句用来控制程序的执行流程。流程控制语句有条件选择语句、循环语句和转移语句三种。
任何程序的结构都是由三种基本的结构组成的。这三种基本结构是：顺序结构、分支结构和循环结构。在Java程序中，通常一个以分号（;）结束的符号串称为一条语句。在顺序结构的程序或程序段中，程序是按语句次序、下一条语句接上一条语句顺序被执行的。
在分支结构或循环结构的程序或程序段中，程序不是按语句次序顺序执行的，而是按分支结构语句或循环结构语句所规定的执行流程来执行的。为了满足实际应用问题的设计需要，分支结构和循环结构有各种各样的变形。另外，实际的程序设计中，经常需要转移语句与分支语句或循环语句结合使用。
Java语言的流程控制语句有：
 分支语句：if，switch
 循环语句：for ，while，do-while
 转移语句：break，continue
另外，函数或类的成员函数在运行结束后，需要返回原调用处，并可能需要带回函数或成员函数的返回值，这种流程控制用return语句来实现。
1、分支语句

分支结构是指程序按照当前的分支条件控制程序流程的执行。
有：if语句和switch语句
if语句实现二路分支，switch语句实现多路分支。
1.if语句
（1）基本的if 语句
if 语句的语法形式为：
if (<</SPAN>逻辑表达式>)
<</SPAN>语句组1>;
[else <</SPAN>语句组2>;]

其中，逻辑表达式的计算值是一个只可能是true或false的逻辑值。if语句的含义是：当<</SPAN>逻辑表达式>的值为true时，执行if 后面的<</SPAN>语句组1>；当<</SPAN>逻辑表达式>的值为false时，执行else后面的<</SPAN>语句组2>。当执行的语句组中的语句多于一条时，语句组必须用一对花括号“{}”括起来。在Java语言的语法中，一对方括号“[]”括起来的部分，表示该部分（除数组定义外）是任选的。因此，else语句是任选的，当没有else语句时，若<</SPAN>逻辑表达式>的值为false时就执行if 语句后边的语句。
【例2.3】找出a、b两个数中的较大者并输出。
方法一：用if-else结构实现。
public class Exam2_3
{
public static void main(String args[])
{
int a = 5, b = 6, max;
if( a > b )
{
max = a;
System.out.println("max = " + max);
}
else
{
max = b;
System.out.println("max = " + max);
}
}
}
方法二：用没有else的if结构实现。
public class Exam2_3_2
{
public static void main(String args[])
{
int a = 5, b = 6, max;
max = a;
if( b > a )
max = b;
System.out.println("max = " + max);
}
}

例2.3中if语句的逻辑表达式中只有一个条件。当问题复杂时，if语句的逻辑表达式中的条件可能多于一个，这称为复合条件。
复合条件需要用逻辑运算符——逻辑与（&&）、逻辑或(||)、逻辑非（!）、逻辑异或（^）等逻辑运算符来组合条件。
例如下面的if语句条件为，判断n是否为一个1至100区间的数：
if (n >= 1 && n <= 100)
如果n既大于等于1又小于等于100，则条件为true，否则条件为false。
（2）if语句嵌套
如果if语句中又包括另一个if语句，则称为if语句嵌套。
if (n >= 1)
{
if (n <= 100) ……
}
else ……
在两个嵌套的if语句中，如果有一个if语句省略了else语句，会产生二义性。如：
if (n >= 1)
if (n <= 100) ……
else ……
此时，else是和哪个if语句匹配容易产生混淆。Java语言规定：else总是与最近的一个if语句匹配。
所以此处else应理解为是与第二个if语句匹配（注意：书写的缩进格式与匹配无关）。如果要求else是与第一个if语句匹配，则程序应写为：
一个if语句可以有两个分支，利用if语句嵌套可以组合出多于两个的分支。

【例2.4】找出三个整数中的最大数并输出。
方法一：用if语句嵌套方法。
public class Exam2_4
{
public static void main(String args[])
{
int a = 3, b = 1, c = 2, max;
if(a < b)
if (b < c)
max = c;
else
max = b;
else
if (a < c)
max = c;
else
max = a;
System.out.println("max = " + max);
}
}
程序运行结果：
max = 3

方法二：用条件的逻辑组合方法。
public class Exam2_4_2
{
public static void main(String args[])
{
int a = 3, b = 1, c = 2, max;
if(a < b && b < c)
max = c;
else if(a < b && c < b)
max = b;
else if (a > b && a < c)
max = c;
else //即(a > b && a > c)
max = a;
System.out.println("max = " + max);
}
}
说明：条件两两组合，所以条件的逻辑组合共有四种情况。此问题可不考虑两个数相等的情况。

2.switch语句
switch语句是多个分支的流程控制语句
语法形式为：
switch (<</SPAN>表达式>)
{
case<</SPAN>常量1>:<</SPAN>语句组1>;
[break;]
case<</SPAN>常量2>:<</SPAN>语句组2>;
[break;]
……;
[default;<</SPAN>语句组>]
}
其中switch、case 、default是关键字，default语句是任选的。
switch语句的语义是：将<</SPAN>表达式>的值按照从上至下的顺序与case语句中给出的常量值进行比较，当表达式的值与某个case语句中的常量值相等时，就执行相应case后的语句序列；若没有一个常量值与表达式的值相等，则执行default语句。如果没有default语句，并且表达式与所有case的常量都不相等时，则不做任何操作。
switch表达式和case常量值的类型可以是byte、short、int、long和char，但不能为boolean，并且要求两者的数据类型必须一致。
3.switch语句中的break语句
switch语句本身并不能保证执行完一组case后的语句或语句组后，跳过随后的case判断，通常情况下，此时需要用break语句来跳过随后的case语句。
break语句的语法形式是：
break;
switch语句中的break语句的语义是：跳过break语句所在位置随后所有的case语句，即结束switch语句的执行。

【例2.5】 把数值表示的星期转换成相应的英文表示并显示。
public class Exam2_5
{
public static void main(String args[])
{
int week = 5;
System.out.print("week = " + week + " ");
switch (week)
{
case 0: System.out.println("Sunday"); break;
case 1: System.out.println("Monday"); break;
case 2: System.out.println("Tuesday"); break;
case 3: System.out.println("Wednesday");break;
case 4: System.out.println("Thursday"); break;
case 5: System.out.println("Friday"); break;
case 6: System.out.println("Saturday"); break;
default: System.out.println("Data Error!");
}
}
}
程序运行结果：
week = 5 Friday
2、循环语句

循环结构是指程序按照当前的循环条件控制程序流程的执行。Java语言有三种循环结构的语句：for语句、while语句和do-while语句。这三种循环语句虽然控制循环的方式不同，但实现循环的功能相同。换句话说，对于任何一个循环问题，这三种循环语句都可以实现。但是，不同的循环问题，使用这三种循环语句的简便程度不同。因此，一个好的程序设计者，应该学会针对不同的循环问题，选择最简便的循环语句。
1.for语句
for语句的语法形式为：
for ([<</SPAN>表达式1>];[<</SPAN>表达式2>];[<</SPAN>表达式3>])
<</SPAN>循环体>;
for语句的语义是：首先计算<</SPAN>表达式1>的值，然后计算<</SPAN>表达式2>的值，如果<</SPAN>表达式2>值为true时，执行一次<</SPAN>循环体>，再计算<</SPAN>表达式3>的值，并进行下一次循环过程；当<</SPAN>表达式2>的值为false时，循环过程结束。
在for语句中，<</SPAN>表达式1>是给循环变量赋初值，因此，<</SPAN>表达式1>通常是一个赋值表达式；<</SPAN>表达式2>是给出循环结束条件，因此，<</SPAN>表达式2>必须是一个关系表达式或逻辑表达式；<</SPAN>表达式3>是改变循环变量，因此，<</SPAN>表达式3>必须是一个赋值表达式（或类似i++形式的改变变量i的数值的语句）；<</SPAN>循环体>可以是一条语句，也可以是多条语句，当为多条语句时，必须用一对花括号“{}”括起来。
说明：无论是<</SPAN>表达式1>还是<</SPAN>表达式2>或者是<</SPAN>表达式3>，都可以任选。
【例2.6】 求1到10的累加和。
for语句最适合于循环次数已知的循环结构。此问题的循环次数已知，因此，此问题适合于用for语句实现。
public class Exam2_6
{
public static void main(String args[])
{
int i, n = 10, sum = 0;

for(i = 1; i <= n; i++)
sum = sum + i;
System.out.println("Sum = " + sum);
}
}
程序运行结果为：
Sum = 55
上述for语句循环过程也可以设计成递减形式的，此时的for语句为：
for(i = n; i >= 1; i--)
sum = sum + i;

2.while语句
while语句的语法形式为：
while (<</SPAN>逻辑表达式>)
<</SPAN>循环体>;
while语句的语义是：如果<</SPAN>逻辑表达式>的计算结果为true时，则执行循环体；如果<</SPAN>逻辑表达式>的计算结果为false时，则结束while语句的执行。同样，当<</SPAN>循环体>中的语句多于一条时，需要用一对花括号“{}”括起来。
例如用while语句实现求1到10累加和的程序段如下：
int i = 1，n = 10，sum = 0;
while (i <= n)
{
sum = sum + i;
i++;
}

和for语句相比，while语句循环中的循环变量赋初值（i = 1）、循环过程结束判断（i <= n）和循环变量修改（i++）三个部分都有，只是放在了不同的地方。
在while语句的循环结构中，初学者最容易犯的一个错误是，忘记在循环体中修改循环变量的值，此时循环过程将永不结束，俗称为“死循环”。如上面的程序段中如果没有i++语句，则循环过程将永不结束。
死循环的另一种情况是，循环结束条件永远无法满足。例如：
int i = 1，n = 10，sum = 0;
while (i >= 0)
{
sum = sum + i;
i++;
}

上述程序段的循环体中虽然有i++语句改变循环变量i的值，但i值的变化永远都满足i >= 0，即循环结束条件永远不会满足，因此造成死循环。
while语句适合于循环次数不确定的情况。如上所示，虽然while语句也可以用来构造循环次数已知的循环过程，但是，很显然，此种情况用for语句构造循环过程更简单、更明了一些。
【例2.7】求两个不为0的正整数的最大公约数。
对于求两个不为0的正整数的最大公约数问题，欧几里德提出了辗转相除算法，其算法思想是：
（1）令m为两个整数中的较大者，n为两个整数中的较小者；
（2）用m除以n，令r为m除以n的余数；
（3）若r不等于0，则令m等于n，n等于r，返回步骤（2）继续；若r等于0，则n中的数值就是两个整数的最大公约数。
从上述算法思想可知，该算法是一个循环过程，并且该循环过程的循环次数事先无法知道，因此，该问题适合于用while语句构造循环过程。
public class Exam2_7
{
public static void main(String args[])
{
int m = 48, n = 32, r = 0, temp;

if(m <= 0 || n <= 0)
{
System.out.println("数据错误！");
return;
}

if(m < n) //保证m >= n
{
temp = m;
m = n;
n = temp;
}
r = m % n; //循环初始化
while(r != 0) //循环条件判断
{
m = n;
n = r;
r = m % n; //循环变量修改
}
System.out.print("最大公约数 = " + n);
}
}
程序运行结果：
最大公约数 = 16
当然，上面程序中的循环过程也可以用for语句构造，用for语句构造循环过程相应的程序段如下：
for(r = m % n; r != 0; r = m % n) //for循环
{
m = n;
n = r;
}

for语句的循环过程中，也必须有循环初始化（r = m % n）、循环条件判断（r != 0）和循环变量修改（r = m % n），只是处于不同的位置而已。显然，在循环次数不知时，用for语句构造的循环过程不及用while语句构造的循环过程清晰。
3.do-while语句
do-while语句的语法形式为：
do
{
<</SPAN>语句组>;
} while (<</SPAN>逻辑表达式>) ;
do-while语句的语义是：首先执行语句组（或称循环体），然后计算<</SPAN>逻辑表达式>的值，当<</SPAN>逻辑表达式>的值为true时，执行一次循环体；当<</SPAN>逻辑表达式>的值为false时，结束循环。
从语义看，do-while语句和while语句的惟一差别是：do-while语句至少执行一次循环体（因其结束条件判断在后面进行）；而对于while语句来说，当一开始循环条件就不满足时，循环体将一次也不执行。
例2.7求最大公约数程序的循环部分也可以用do-while语句构造。用do-while语句的相应程序段如下：
r = m % n; //循环初始化
if(r != 0) //判断初始时r是否为0
do
{
m = n;
n = r;
r = m % n; //循环变量修改
} while(r != 0); //循环结束条件判断

由于语句r = m % n的计算结果可能使r等于0，而do语句在第一次执行循环体时，并不做任何判断，这将可能造成因r等于0使n等于0，因n等于0使语句r = m % n的运算出现除数等于0的错误，因此要在do语句之前判断r是否等于0。只有在r不等于0时才执行do语句；在r等于0时最大公约数已经得到。
显然，对于求最大公约数问题，用while语句比用do-while语句简单一些。但在有些情况下，用do-while语句构造循环过程比用while语句简单一些。

4.多重循环
如果循环语句的循环体内又有循环语句，则构成多重循环结构。多重循环结构中的循环语句，可以是前面讨论过的for语句、while语句或do-while语句中的任何一种。
【例2.8】输出九九乘法表。
程序如下：
public class Exam2_8
{
public static void main(String args[])
{
int i,j,n = 9;
for(i = 1; i <= n; i++) //外层循环
{
for(j = 1; j <= i; j++) //内层循环
System.out.print(" " + i*j); //输出
System.out.println(); //每行结束时换行
}
}
}
说明：这个问题中，两重循环的循环次数都已知，因此两重循环都用for语句构造循环过程。外层for语句的循环变量是i，控制总共打印多少行，内层for语句的循环变量是j，控制每行显示多少列。
程序运行结果为：
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
8 16 24 32 40 48 56 64
9 18 27 36 45 54 63 72 81
当应用问题复杂时，程序一般需要有多重循环结构，此时最重要的是要把程序设计的思路梳理清楚，而其中的每一重循环结构都可以按单重循环结构设计。

3、break语句和continue语句

break语句通常是和switch语句或循环语句配合使用，continue语句通常是和循环语句配合使用。
1.break语句
break语句的语法形式是：
break;
在上节讨论switch语句时，我们已结合介绍了switch语句中的break语句使用方法。这里我们主要介绍循环语句中的break语句使用方法。在循环语句中，break语句的功能是跳出循环体。特别需要说明的是，当break语句位于多重循环语句的内层时， break语句只能跳出它当前所处的那层循环体。
【例2.9】循环语句中break语句使用方法示例。
public class Exam2_9
{
public static void main(String args[])
{
int i, j, k;

for(i = 1; i <= 6; i++) //第1层循环
{
for(j = 1; j <= 6; j++) //第2层循环
{
for(k = 1; k <= 6; k++) //第3层循环
{
System.out.println("k = " + k + " ");
if(k == 2) break; //跳出第3层循环
}
System.out.println("j = " + j + " ");
if(j == 2) break; //跳出第2层循环
}
System.out.println("i = " + i + " ");
if(i == 2) break; //跳出第1层循环
}
}
}

由于break语句的作用，此程序的第3层的输出语句（输出k）只执行了8次，第2层的输出语句（输出j）只执行了4次，第1层的输出语句（输出i）只执行了2次。

2.continue语句
continue语句的语法形式为：
continue;
continue语句主要用于循环语句中，continue语句的语义是：若循环体中遇到continue语句，则本次循环体的后续语句被忽略，回到循环条件判断处，判断是否执行下一次循环体。换句话说，continue语句仅跳过当前层循环体的剩余语句。
【例2.10】continue语句使用方法示例。
public class Exam2_10
{
public static void main(String args[])
{
int i, j;

for(i = 1; i <= 6; i++)
{
for(j = 1; j <= 6; j++)
{
if(j >= 3) continue; //continue语句
System.out.println("j = " + j + " ");
}
}
}
}
由于continue语句的作用，第2层的输出语句只执行了12次。

4、return语句
return语句的语法形式为：
return [<返回值>];
return语句的语义是：使函数返回原调用处，且带回返回值。如果函数为void类型，则return语句后没有<返回值>；如果函数为非void类型，则return语句后需要有<返回值>，并且<返回值>的类型必须和函数的类型一致。
当return语句不带<返回值>，并且位于函数的最后时，return语句可以省略。
return语句的具体使用方法可参见随后各章的程序设计举例。
7、程序注释
Java语言允许在程序中添加注释，以增加程序的可读性。前面的例子中已经多次使用了程序注释。注释主要是给人阅读的，所以系统不会对注释的内容进行编译。
Java语言有三种形式的注释：
单行注释 // 注释内容

多行注释／＊　＊／

文件注释／＊＊

　　　　＊

　　　　＊

　　　　＊／