java入门基础（4）

第 4 章  控制程序流程语句
当 Java 程序执行时，通常是按照在语句源文件中出现的顺序从上到下地依次执行。但是，通过控制
流程语句的条件判断、循环、分支等，可以打断执行的流程，使程序有条件地执行特定的代码块。
Java 语言中的程序流程控制语句有三种：顺序结构、条件判断结构和循环结构。其中顺序结构最简
单，程序依次执行各条语句。Java 的每条语句一般以分号(“；”)作为结束标志。所以本章重点讲解条件
判断结构和循环结构。
我们将学习如下条件判断语句：if-then、if-then-else 和 switch。学习如下循环语句：for、while 和
do-while。学习如下分支语句：break、continue 和 return。
4.1   条件判断语句
在程序设计时，经常需要使用条件判断结构在程序中完成条件判断和选择功能，这就需要使用到条
件判断语句。Java 中的条件判断语句包括 if-then 语句、if-then-else 语句和 switch 语句。条件判断语句用
来控制选择结构，对选择条件进行判断，并根据判断结果选择要执行的程序语句，改变程序执行流程。
4.1.1   if-then 语句
在实际生活中，经常会需要做一些条件判断，并根据条件判断结果做出选择。例如，当一个男孩子
向一个非常理智的女孩子求婚时，这个女孩子思考的逻辑可能是这样的：
如果你有 100 万
那么，我就嫁给你！
在这里，女孩子嫁给男孩子这个过程的实施，必须以“你有一百万”为前提。只有条件判断“你有
一百万”这一前提条件为真时，“那么，我就嫁给你！”这个行为才能得到执行。在生活当中，类似这
样的情形是很常见的。
相应地，在 Java 程序设计语言中，也有相应的条件语句来完成类似的条件判断和有选择地执行这样
的功能，这就是 if-then 语句。if-then 语句的语法格式如下。
if(条件表达式)
语句
或者
if(条件表达式){
一条或多条语句
}
if-then 语句执行的过程如下。
（1）对 if 后面括号里的条件表达式进行判断。
（2）如果条件表达式的值为 true，就执行表达式后面的语句或后面大括号里的多条语句。
（3）如果条件表达式的值为 false，则跳过 if 语句，执行下一条语句。 
2
if-then 语句是只有一个选择的语句结构，所以又叫单分支选择结构，其流程图如图 4.1 所示。
条件表达式
一条或多条语句
true
false
图 4.1   if 语句流程图
需要注意的是，在条件表达式的右括号后面，如果只有一条执行语句的话，那么可以跟一对大括号，
也可以不跟大括号。如果有多条语句需要一起执行，则必须用大括号把多条语句括起来，形成语句块。
建议不论条件成立时后面要执行多少条语句，一律用大括号括起来。请看下面的代码。
int a = 2,b = 3; 
if(a > b)
System.out.println(“这句话能输出！”);
System.out.println(“这句话也能输出！”);    //这个输出语句并不是条件表达式后的执行语句
因为没有用大括号将条件表达式 a>b 后的两个输出语句括起来，所以条件表达式成立与否，只影响
到其后第一个输出语句。这段代码的输出结果为：
“这句话也能输出！”
用 if 语句表示女孩子考虑求婚问题，可以以自然语法写成如下形式：
if(男朋友有 100 万){
我愿意嫁给你！
}
当然，在程序中，需要使用 Java 语言的语法来表示，如下所示。
float boyFriendMoney;          //变量 boyFriendMoney 代表男朋友的存款
...
if(boyFriendMoney > 100){        //如果男朋友的存款多于 100 万
System.out.println(“我愿意嫁给你！”);  //那么，同意嫁给他
}
4.1.2   if-then-else 语句
有时候，需要根据条件判断结果分别做出选择。例如，在上节的例子中，当一个男孩子向一个女孩
子求婚时，女孩子思考的逻辑也可能是这样的：
如果你有 100 万
那么，我就嫁给你！
否则
我就拒绝嫁给你。
在这里，女孩子根据对方是否有一百万，有两个选择：当条件判断“你有一百万”这一前提条件为
真时，执行“那么，我就嫁给你！”这个行为；否则，如果条件判断不为真，就执行“我就拒绝嫁给你”。
在生活当中，类似这样的情形是很常见的。
相应地，在 Java 程序设计语言中，也有相应的条件语句来完成类似的逻辑判断和有选择地执行这样
·3·
的功能，这就是 if-then-else 语句。if-then-else 语句的语法格式如下。
if(条件表达式)
语句 1
else
语句 2
或者
if(条件表达式){
语句块 1
}else{
语句块 2
}
if-then-else 语句执行的过程如下。
（1）对 if 后面括号里的条件表达式进行判断。
（2）如果条件表达式的值为 true，就执行语句 1 或语句块 1。
（3）如果条件表达式的值为 false，就执行语句 2 或语句块 2。
if-then-else 语句又称为双分支选择结构，其流程图如图 4.2 所示。
条件表达式
语句1或语句块1 语句2或语句块2
true false
图 4.2   if-else 语句流程图
【例 4.1】编写一个程序，求两个数中比较大的值，并输出。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 MaxValueExample.java。
public class MaxValueExample{
public static void main(String[] args){
int a=23,b=36,max;            //声明三个整型变量
if(a>b){                //如果 a 大于 b
max = a;              //将较大值的 a 赋给变量 max
}else{                //否则，如果 a 不大于 b
max = b;              //将 b 的值赋给变量 max
}
System.out.println(‚最大值是：‛  + max);  //输出变量 max 的值，即输出最大值
}
}
（2）使用如下命令编译和运行 MaxValueExample.java 源程序。
javac MaxValueExample.java
java MaxValueExample
（3）程序输出结果如下。
最大值是：36 
4
在程序 MaxValueExample.java 中，定义三个整型变量 a、b 和 max。对变量 a 和 b 的值进行判断，
并将其中较大的值赋给变量 max，最后输出 max 的值。
有的时候，条件判断的结果不只有两种，有可能有超过两个以上的执行路径，这时可以使用多个
else-if 子句实现，其语法格式如下。
if(条件表达式 1){                //如果条件表达式 1 成立（结果为 true）
语句块 1                  //就执行语句块 1 中的代码
}else if(条件表达式 2){              //否则，如果条件表达式 2 成立
语句块 2                  //就执行语句块 2 中的代码
}
…                      //对其他条件进行判断
else if(条件表达式 n-1){              //如果条件表达式 n-1 成立
语句块 n-1                //就执行语句块 n-1 中的代码
}else{                    //如果以上所有的条件都不成立
语句块 n                  //就执行语句块 n
}
该语句执行的过程如下。
（1）对 if 后面括号里的条件表达式进行判断。
（2）如果条件表达式的值为 true，就执行语句块 1。
（3）否则，对条件表达式 2 进行判断。如果条件表达式的值为 true，就执行语句块 2。
（4）否则，依此类推。
（5）如果所有条件表达式的值都为 false，最后执行语句块 n。
这种多分支语句依次对 if 后面的条件表达式进行判断，遇到第一个值为真的表达式时，就执行其后
面的语句块，然后整个条件判断语句就结束了，不再对后面的条件表达式进行判断和执行了。理论上，
可以有无限多个 else-if 子句。
【例 4.2】编写一个程序，根据学生的成绩，判断其属于哪个档次，并输出。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 ScoreExample.java。 
public class ScoreExample{
public static void main(String[] args){
int score = 85;                //定义代表学生成绩的变量 score，并赋初值
if(score >= 90){                //如果成绩大于等于 90 分
System.out.println("您的成绩优秀！‛);    //执行这个语句块，并结束本 if-else-if 语句
}else if(score >= 80){              //满足这个条件表达式
System.out.println(‚您的成绩良好‛);    //执行这个语句块，并结束本 if-else-if 语句
}else if(score >= 70){              //如果成绩大于等于 70 分
System.out.println(‚您的成绩中等‛);    //执行这个语句块，并结束本 if-else-if 语句
}else if(score >= 60){              //如果成绩大于等于 60 分
System.out.println(‚您的成绩及格‛);    //执行这个语句块，并结束本 if-else-if 语句
}else{                  //如果以上条件都不成立，即成绩小于 60 分
System.out.println(‚您的成绩不及格‛);
}                    //结束 if 语句是直接转到这里，执行 if 后面的语句
}
}
（2）使用如下命令编译和运行 ScoreExample.java 源程序。
javac ScoreExample.java
java ScoreExample
（3）程序输出结果如下。 
·5·
您的成绩良好
在本例中，当程序执行到 score >= 80 这个表达式时，计算其结果为 true，执行其后的语句块，输出
“您的成绩良好”，并结束整个条件判断语句，转到该语句最后一个大括号后面，执行其后面的语句。
多分支选择结构流程图如图 4.3 所示。
条件表达式1
语句块1语句块2
true
false
条件表达式2
true
false
语句块n-1
true
条件表达式n-1
false
语句块n
„„
true
„„
false
图 4.3   if-else-if 语句流程图
需要注意的是，最后的 else 语句可以省略，那么当所有的条件表达式都不成立时，什么也不执行。
【例 4.3】编写一个程序，求三个整数中的最大值，并输出。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 MaxValueExample2.java。 
public class MaxValueExample2{
public static void main(String[] args){
int a=23,b=36,c=25,max;           //  声明 4 个整型变量，其中 a,b,c 赋初值
if(a>c){                //  如果 a 比 c 大
max = a;              //  那么把 a 赋给 max 变量
}else if(b>c){              //  如果 a 比 c 小，那么 b 与 c 进行比较。如果 b 大于 c
max = b;              //  那么最大值为 b
}else                  //  否则，a 和 b 都不大于 c
max = c;              //  那么最大值为 c
System.out.println(‚最大值是：‛  + max);  //  输出最大值 max 的值
}
}
（2）使用如下命令编译和运行 MaxValueExample2.java 源程序。
javac MaxValueExample2.java
java MaxValueExample2
（3）程序输出结果如下。
最大值是：36
在程序 MaxValueExample2 中，对三个整数 a、b 和 c 进行比较。实际上，这个程序逻辑并不完整，
例如，将变量 a 的值改为 26，再编译并运行此程序，会发现输出的最大值为 26，显然是不正确的。这
是因为没有考虑 a 大于 c 但小于 b 的情况。这时，需要使用嵌套的 if 语句。 
6
4.1.4   条件判断语句的嵌套
if 语句里面可以再嵌套 if 语句。所谓嵌套，就是在 if 语句中又包含一个或多个 if 语句。这样的语句
一般用在比较复杂的分支语句中。其语法格式如下。
if(条件表达式 1){
if(条件表达式 2){
语句块 1
}else{
语句块 2
}
}else{
if(条件表达式 3){
语句块 3
}else{
语句块 4
}
}
【例 4.4】使用嵌套的 if-then-else 语句编写一个程序，根据学生的成绩，判断其属于哪个档次，并
输出。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 ScoreExample2.java。 
public class ScoreExample2{
public static void main(String[] args){
int score = 85;              //  声明初始整型变量 score，并赋初值
if(score >=60){              //  如果成绩大于等于 60，再进一步判断
if(score >= 70){            //  如果成绩大于等于 70，再进一步判断
if(score >= 80){          //  如果成绩大于等于 80，再进一步判断
if(score >= 90)        //  如果成绩大于等于 90，输出相关信息
System.out.println("您的成绩优秀！‛);
else            //  如果成绩在 80~90 之间，输出相关信息
System.out.println(‚您的成绩中等‛);
}else{            //  如果成绩在 70~80 之间，输出相关信息
System.out.println(‚您的成绩良好‛);
}
}else{              //  如果成绩在 60~70 之间，输出相关信息
System.out.println(‚您的成绩及格‛);
}
}else{                //  如果成绩小于 60
System.out.println(‚您的成绩不及格‛);
} 
}
}
（2）使用如下命令编译和运行 ScoreExample2.java 源程序。
javac ScoreExample2.java
java ScoreExample2
（3）程序输出结果如下。
您的成绩良好
同样求三个整数中的最大值，也可以使用嵌套的 if-else 语句。请看下面的示例。
【例 4.5】使用嵌套的 if-then-else 语句编写一个程序，求三个整数中的最大值，并输出。编写程序
·7·
的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 MaxValueExample3.java。
public class MaxValueExample3{
public static void main(String[] args){
int a=23,b=36,c=25,max;           //声明三个整型变量
if(a>c){                //如果 a>c，最大值在 a 和 b 中间
if(a>b)
max = a;
else 
max = b;
}else{                //如果 a<c，最大值在 b 和 c 中间
if(b>c)
max = b;
else
max = c;
}
System.out.println(‚最大值是：‛  + max);
}
}
（2）使用如下的命令编译和运行 MaxValueExample3.java 源程序。
javac MaxValueExample3.java
java MaxValueExample3
（3）程序输出结果如下。
最大值是：36
注意，else 总是和离它最近的 if 进行匹配，所以在 if-then-else 语句嵌套时，尽可能使用大括号进行
划分逻辑关系，避免出现问题。例如，上例也可以这样来编码：
public class Test{
public static void main(String[] args){
int score = 85;          //声明整型变量，并赋初值
if(score >=60){          //如果变量 score（成绩）的值大于等于 60，再做进一步的判断
if(score > 89)        //如果变量 score（成绩）的值大于 89，输出相关的信息
System.out.println(‚恭喜您！您的得分是优秀！‛);
}else              //如果成绩小于 60，输出相关信息
System.out.println(‚很抱歉，您考试不及格！‛);
}
}
上面代码中第一个 if 语句后面的大括号是必须的，这时什么也不输出。如果去掉第一个 if 语句后面
的大括号，那么，else 子句将与它最近的那个 if 语句匹配，这时代码如下所示。
public class Test{
public static void main(String[] args){
int score = 85;
if(score >=60)
if(score > 89)
System.out.println(‚恭喜您！您的得分是优秀！‛);
else              //与最近的 if 语句相匹配，因此当 score 小于等于 89 时，输出信息
System.out.println(‚很抱歉，您考试不及格！‛);
}
} 
8
上面代码的输出结果如下。
“很抱歉，您考试不及格！”
很明显，输出结果不是所期望的。因此建议，为了避免这种情况，最好的方法是加上大括号为代码
划分界限。
4.1.5   switch 语句
当选择结构的分支越多时，if-then-else 语句就会变得越来越难以看懂。Java 提供了另一种多分支语
句—switch 语句。switch 语句是多分支的开关语句，其语法格式如下。
switch(表达式){
case  常量表达式 1：语句组 1；
[ break;]
case  常量表达式 1：语句组 1；
[ break;]
…
case  常量表达式 1：语句组 1；
[ break;]
default：语句块 n
}
说明：
  switch 后面的表达式值的数据类型可以是字符型（char）、字节型（byte）、短整型（short）或
者整型（int） 等原始数据类型，但是不可以是布尔型（boolean）、长整型（long）、浮点型（float、
double）。
  switch 后面的表达式值的数据类型，还可以是枚举类型（Enum），或者原始数据类型的包装类
（Character、Byte、Short、Integer）。关于枚举类型和原始数据类型的包装类，在后面章节详
细讲解。从 JDK7 开始，switch 后面的表达式值的数据类型也支持字符串（String）类型。
  case 后面的常量表达式的值的类型，必须与 switch 后面的表达式值的类型相匹配，而且必须是
常量表达式或直接字面量。
  break 语句会中断 switch 语句的执行，即结束 switch 语句。break 语句可以省略。如果省略，那
么程序会按顺序执行 switch 中的每一条语句，直到遇到右大括号或 break 为止。
  语句块可以是一条语句或多条语句，但不需要使用大括号括起来。
  case 分支语句和 default 语句都不是必需的，可以省略。
switch 语句执行的过程如下。
（1）将 switch 表达式的值与各个 case 后面的常量表达式的值一一进行比较。
（2）当表达式的值与某个 case 分支的值相等时，程序执行从这个 case 分支开始的语句组。
（3）如果没有任何一个 case 分支的值与 switch 表达式的值相匹配，并且 switch 语句含有 default
分支语句，则程序执行 default 分支中的语句组。
（4）直到遇到 break 语句或右大括号，结束 switch 语句。
switch 语句的执行流程图如图 4.4 所示。 
·9·
条件表达式1 语句组1
语句组2 条件表达式2
语句组n-1
true
条件表达式n-1
false
default:语句块n
„„
false
break;
break;
false
true
true break;
false
图 4.4   switch 语句流程图
【例 4.6】使用 switch 语句编写一个程序，要求根据学生成绩等级，输出成绩为“优秀”、“良好”、
“中等”、“及格”和“不及格”。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 SwitchExample.java。 
public class SwitchExample{
public static void main(String[] args){
char studentGrade =  ‘B’;        //声明字符变量，并赋初值
switch(studentGrade){          //匹配 studentGrade 的值
case  ‘A’:              //如果 studentGrade 的值与'A'或'a'相符
case „a‟:
System.out.println(‚优秀‛);
break;            //结束 switch 语句
case  ‘B’:            //如果 studentGrade 的值与'B'或'b'相符
case „b‟:
System.out.println(‚良好‛);
break;            //结束 switch 语句
case  ‘C’:            //如果 studentGrade 的值与'C'或'c'相符
case „c‟:
System.out.println(‚中等‛);
break;            //结束 switch 语句
case  ‘D’:            //如果 studentGrade 的值与'D'或'd'相符
case „d‟:
System.out.println(‚及格‛);
break;            //结束 switch 语句
default:              //如果以上条件都不相符
System.out.println(‚不及格‛);
}
}
}
（2）使用如下命令编译和运行 SwitchExample.java 源程序。
javac SwitchExample.java
java SwitchExample 
10
（3）程序输出结果如下。
良好
在这个例子中，执行 switch 语句时，将学生的分数 studentGrade 依次与 case 后面的字符常量进行比
较，当分数为字符‘B’时，执行其后面的语句。由于“case „B‟”后面为空语句，程序会按顺序执行，
进而执行“case „b‟”后面的语句，即输出字符串“良好”。再往下执行，遇到 break 语句，程序结束 switch
语句，跳转到 switch 语句的右大括号处，switch 语句结束。
【例 4.7】给定一个年份值，计算该年份的 2 月份天数（根据该年份是不是闰年， 2 月份的天数具有
不同的值）。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 SwitchExample2.java。 
public class SwitchExample2{
public static void main(String[] args){
int month = 2;
int year = 2012;
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("无效的月份.");
break;
}
System.out.println("2 月的天数是：  " + numDays);
}
}
（2）使用如下命令编译和运行 SwitchExample.java 源程序。
javac SwitchExample2.java 
·11·
java SwitchExample2
（3）程序输出结果如下。
2 月的天数是：29
【例 4.8】基于字符串的月份名称，显示了所在月份的数字。
在 JDK 7 及以后版本中，可以在 switch 语句表达式中使用 String 对象。这个示例程序演示了这种用
法。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 StringSwitchExample.java。 
public class StringSwitchExample {
//  一个单独的方法，在该方法内，对方法参数 month 进行判断
public static int getMonthNumber(String month) {
int monthNumber = 0;
//  如果 month 值为 null，则返回一个 0 值
if (month == null) {
return monthNumber;
}
switch (month.toLowerCase()) {
case "一月":
monthNumber = 1;
break;
case "二月":
monthNumber = 2;
break;
case "三月":
monthNumber = 3;
break;
case "四月":
monthNumber = 4;
break;
case "五月":
monthNumber = 5;
break;
case "六月":
monthNumber = 6;
break;
case "七月":
monthNumber = 7;
break;
case "八月":
monthNumber = 8;
break;
case "九月":
monthNumber = 9;
break;
case "十月":
monthNumber = 10; 
12
break;
case "十一月":
monthNumber = 11;
break;
case "十二月":
monthNumber = 12;
break;
default:
monthNumber = 0;
break;
}
return monthNumber;
}
public static void main(String[] args) {
String month = "八月";
int returnedMonthNumber = StringSwitchDemo.getMonthNumber(month);
if (returnedMonthNumber == 0) {
System.out.println("无效地月份");
} else {
System.out.println(returnedMonthNumber);
}
}
}
（2）使用如下命令编译和运行 SwitchExample.java 源程序。
javac StringSwitchExample.java
java StringSwitchExample
（3）程序输出结果如下。
8
在上面的程序中，为了忽略输入月份的大小写，使用了 toLowerCase()方法将月份字符串转换为小写。
需要注意的是，上面的示例代码中，在比较之前要先检查 switch 语句中的表达式是否为 null。确保
该表达式不为 null，否则会抛出 NullPointerException 空指针异常。
4.1.6   if-then-else 语句与 switch 语句的区别
从功能上来讲，if-then-else 语句和 switch 语句都是多分支选择语句，在通常情况下，对于多分支选
择结构，使用 if-then-else 语句和使用 switch 语句从作用上讲是相同的。但是在实际编写程序时，一般遵
循下面的使用原则。
（1）如果分支的层次不超过三层，那么通常使用 if-then-else 语句；否则，使用 switch 语句。
（2）如果条件判断语句是对一个变量是否属于一个范围进行判断，如“a>60 && a<89”，这时要
使用 if-then-else 语句。
（3）如果是对同一个变量的不同值作条件判断时，既可以使用 if-then-else 语句，也可以使用 switch
语句。但建议优先使用 switch 语句，其执行效率相对高一些。 
·13·
4.2   循环语句
一个循环是语句或语句集重复执行的任何一段代码块， 当特定的条件为 true 时， 它重复执行同一套
指令。Java 中的循环语句包括：
  while 语句；
  do-while 语句；
  for 语句。
4.2.1   while 循环语句
while 语句的基本语法格式如下：
while(布尔表达式){
语句或语句块
}
说明：
  表达式必须是任何运算结果为布尔值的表达式。
  如果只有一条语句的话，可以省略表达式后面的大括号。但建议不论几条语句，都使用大括号
括起来，这样可以提高代码的可阅读性。
  while(表达式)后面一定没有分号（；），在右大括号后面也没有分号（；），这是初学者经常
容易犯的错误。
while 循环语句的执行过程如下：
（1）首先判断 while 后面小括号中表达式的值，如果为 true，就从后面紧跟的左大括号开始，按顺
序执行大括号里的语句，这称为“执行循环体”。
（2）循环体执行结束，再次返回对 while 后面小括号中的表达式的值进行判断，重复执行上一步，
直到表达式的值为 false。
（3）此时结束执行 while 语句，while 循环结束。
【例 4.9】使用 while 语句编写一个程序。编写程序的步骤如下。
（1）首先打开记事本，编写程序代码如下，并保存为 WhileExample1.java。
public class WhileDemo1{
public static void main(String[] args){
int[ ] mathScore = new int[200];
//为数组中的所有元素赋初值 60
int i = 0;            //定义循环变量
while(i<200){          //循环 200 遍
mathScore[i] = 60;      //为每一个数组元素赋初值 60
i++;            //循环变量自增 1
}
}
}
（2）使用如下命令编译和运行 SwitchDemo1.java 源程序。
javac SwitchExample1.java
java SwitchExample1 
14
在上面这个示例中，首先定义了一个循环变量 i，并赋初值为 0。循环变量 i 用在 while 后面的表达
式 i<200 中，用来作为循环的条件，保证循环只重复 200 次，同时作为数组元素引用的索引值。在循环
体语句中，一定要有改变循环条件的语句 i++。这样每执行一次循环体，变量 i 自增 1，当循环执行 200
遍时，i 的值为 200，循环条件不再成立，结束循环。
改变循环的条件也可以放在 while 后面的表达式中，如例 4.10 所示。
【例 4.10】使用 while 语句编写一个程序，步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 WhileExample2.java。
public class WhileExample2{
public static void main(String[] args){
int i = 0;            //定义循环变量
//输出 200 个‛OK‛
while(i++<200){          //后缀自增运行符++，先将 i 与 200 比较，然后将 i 的值增加 1
System.out.println(“OK”);
}
}
}
在上面这个程序中，对自变量 i 的值的改变，放在 while 后面的括号中。每次将 i 与 200 比较大小后，
i 的值自动增加 1。如果在 while 语句中，没有改变循环条件的语句，那么循环将无限期地执行下去，这
称为“死循环”。
【例 4.11】死循环的程序示例。
public class WhileExample3{
public static void main(String[] args){
int i = 0;            //定义循环变量
//输出 200 个‛OK‛
while(i<200){          //在 while 循环中，没有改变循环变量 i 的条件，所以为死循环
System.out.println(“OK”);
}
}
}
在上例中，因为没有改变循环变量 i 的值的语句，所以条件“i<200”永远成立，循环将会无限期地
执行下去。这在编写程序时是要避免的。while 语句的流程图如图 4.5 所示。
布尔表达式 循环体语句 true
false
图 4.5   while 语句的流程图
【例 4.12】使用 if-then 语句和 while 语句编写一个程序，求 100（含 100）之内所有偶数的和。步
骤如下：
（1）打开记事本，编写程序代码如下，并保存为 EvenExample.java。
//  求 100（含 100）之内所有偶数的和
public class EvenExample{ 
·15·
public static void main(String[] args){
int number = 1, sum=0;          //定义两个整型变量
while(number <= 100){          //当变量 number 的值不大于 100 时
if(number%2 == 0){          //判断 number 是否为偶数
sum = sum + number;      //将偶数的值加到变量 sum 上
}
number++;            //number 变量的值自增 1
} 
System.out.println(‚100(含 100)之内所有偶数的和是：‛  + sum);
}
}
（2）使用如下命令编译和运行 EvenExample.java 源程序。
javac EvenExample.java
java EvenExample
（3）程序输出结果如下。 
100(含 100)之内所有偶数的和是：2550
在程序 EvenExample.java 中，从变量 number 值为 1 开始循环，直到条件 number<=100 不成立为止。
在每一次循环中，都判断变量 number 能否被 2 整除。如果能被 2 整除，就将其值累加到变量 sum 上，
最后循环结束，变量 sum 的值就为 100 以内偶数的和。
4.2.2   do-while 循环语句
与 while 语句功能相似的另一个循环语句是 do-while 语句。在大多数情况下， while 语句和 do-while
语句完成相同的功能，它们的作用是等价的。do-while 语句的基本语法格式如下。
do{
语句或语句块
}while(布尔表达式)；
说明：
  表达式可以是而且必须是任何运算结果为布尔值的表达式。
  如果只有一条语句的话，可以省略 do 后面的大括号。但建议不论几条语句，都使用大括号括起
来。
  while 后面一定要有分号（；），以示 do-while 语句结束，这与 while 语句不同。
do-while 循环语句的执行过程如下。
（1）首先执行 do 后面的循环体语句。
（2）然后对 while 后面小括号中的布尔表达式的值进行判断，如果为 true，再次执行 do 后面的循
环体语句，并再次对布尔表达式的值进行判断；否则，结束循环语句。
（3）重复执行上述两步。
【例 4.13】使用 do-while 语句编写一程序，为一个数组赋初值，步骤如下。
public class DoWhileExample1{
public static void main(String[] args){
int[ ] mathScore = new int[200];
//为数组中的所有元素赋初值 60
int i = 0;                //定义循环变量
do{                  //do-while 循环语句 
16
mathScore[i] = 60;          //为每一个数组元素赋初值 60
i++;                //循环变量 i 改变，自增 1
}while(i<200);              //判断 i<200 是否成立
}
}
这与上节使用 while 语句一样，实现了相同的功能。改变循环的条件也可以放在 while 后面的表达
式中，如下面代码所示。
public class DoWhileExample2 {
public static void main(String[] args){
int[ ] mathScore = new int[200];        //声明大小为 200 的一个整型数组
//为数组中的所有元素赋初值 60
int i = 0;                //定义循环变量
do{                  //执行 do-while 循环语句
mathScore[i] = 60;          //为每一个数组元素赋初值 60
} while(i++ < 200);            //将循环变量 i 放在条件表达式中
}
}
如果在 do-while 语句中，没有改变循环条件的语句，那么循环将无限期地执行下去，这称为“死循
环”，如下面代码所示。
public class DoWhileExample3{
public static void main(String[] args){
int i = 0;                //定义循环变量
//输出 200 个‛OK‛
do{                  //执行 do-while 循环语句
System.out.println(“OK”);
} while( i< 200 );            //判断循环条件。如果条件成立，则继续执行 do 语句块
}
}
在上例中，因为没有改变循环变量 i 的值的语句，所以条件 i<200 永远成立，循环将会无限期地执
行下去。这在编写程序时是要避免的。do-while 语句的流程图如图 4.6 所示。
布尔表达式
循环体语句
true
false
图 4.6  while 语句的流程图
【例 4.14】使用 if-then 语句和 do-while 语句编写一程序，求 100（含 100）之内所有偶数的和。编
写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 EvenDemo2.java。
//  求 100（含 100）之内所有偶数的和
public class EvenExample2{
public static void main(String[] args){ 
·17·
int number = 1, sum=0;      //声明两个整型变量 number 和 sum，并赋初值 
do{
if(number%2==0)      //判断 number 是否为偶数
sum = sum + number;  //如果是偶数，则加总各 sum
number++;        //变量 number 自增
} while(number <= 100);  //对变量 number 的大小进行判断。如果条件成立，则继续执行 do 语句块
System.out.println(‚100(含 100)之内所有偶数的和是：‛  + sum);
}
}
（2）使用如下命令编译和运行 EvenExample2.java 源程序。
javac EvenExample2.java
java EvenExample2
（3）程序输出结果如下。
100(含 100)之内所有偶数的和是：2550
程序 EvenExample2 与 EvenExample 相似，也是求 100 以内偶数的和，但使用的是 do-while 语句。
从结果上看，两个程序的运行结果都是一样的。
虽然 while 语句和 do-while 语句在大多数情况下可以相互替代，是等价的，但是在某些情况下，它
们的使用还是有区别的。while 语句和 do-while 语句的区别如下。
  while 语句是先判断，后执行；而 do-while 语句是先执行，后判断。所以即使一开始循环条件就
不成立，do-while 语句中的循环体也会执行一次。
  一般情况下，使用 while 和 do-while 是等价的，同样的循环，使用 while 和使用 do-while 的结果
是一样的。但是，如果在循环语句一开始布尔表达式就不成立（表达式的值为 false），那它们
的使用结果是不同的。例如下面两个示例：
public class Test1{
public static void main(String[] args){
boolean flag = false;          //声明布尔变量 flag，并赋初值 false
int   value = 0;            //声明整型变量 value，并赋初值 0
while(flag){            //如果 flag 的值为真，就进入循环体执行
value++;
} 
System.out.println("value=" + value);    //输出循环语句执行以后 value 的值
}
}
在 Test1.java 中，使用了 while 循环语句，对布尔类型的条件变量 flag 的值进行判断。如果 flag 的
值为真，就将变量 value 的值增 1。循环执行，直到 flag 的值为 flase 为止，最后输出执行循环语句以后
的变量 value 的值。编译并运行 Test1，其输出结果如下。
value=0
下面的 Test2 与 Test1 几乎一样，除了使用了 do-while 循环语句，先执行 value 自增的操作，然后再
对布尔变量 flag 的值进行判断，其代码如下所示。
public class Test2{
public static void main(String[] args){
boolean flag = false;          //声明布尔变量 flag，并赋初值 false
int   value = 0;            //声明整型变量 value，并赋初值 0
do{                //先执行一次循环体
value++;            //对变量 value 的值进行自增 
18
} while(flag);            //后对布尔变量 flag 的值进行判断
System.out.println(“value=” + value);
}
}
在 Test2 中，使用了 do-while 循环语句。不管布尔变量的初值是否为 flase（即不论初始条件是否成
立），都会先执行 value++语句。编译并运行 Test2，其输出结果如下。
value=1
4.2.3   for 循环语句
for 语句是最经常使用的循环语句，一般用在循环次数已知的情况下。在很多情况下，可以使用 for
语句替代 while 和 do-while 语句，其代码结构更加紧凑和简洁。for 语句的语法格式如下。
for(初始化表达式；条件表达式；增量语句){
循环体语句
}
说明：
  初始化表达式通常用来对循环变量进行初始化，或者定义循环变量并初始化，它在循环过程的
开始执行，且只会被执行一次。
  条件表达式是一个布尔表达式，即运算结果为布尔值的表达式。只有当条件表达式为 true 时，
才会执行或继续执行 for 语句的循环体语句。
  增量表达式用于改变循环条件的语句，为继续执行循环体语句做准备。这里也可以是一个运算
表达式列表，包含 1 个或多个运算表达式。通常这里的表达式用来改变循环变量的值，如自增、
自减等运算。
for 循环语句的执行过程如下。
（1）执行初始化表达式。
（2）对中间的条件表达式的值进行判断，如果为 true，执行后面的循环体语句。
（3）执行增量表达式，改变循环变量的值。
（4）重复执行上述两步，开始下一次循环，直到某次中间的条件表达式的值为 false，结束整个循
环语句。
【例 4.15】使用 for 语句示例：为数组赋初值。
public class ForExample{
public static void main(String[] args){
int[ ] mathScore = new int[200];
//为数组中的所有元素赋初值 60
int i;              //定义循环变量
for(i=0;i<200;i++){        //循环语句，初始化 i 的值为 0；当 i<100 时，循环继续；步长为 1
mathScor[i] = 60;
}
}
}
在上面这个示例中，程序执行到 for 语句时，先对循环变量 i 赋初值 0，然后判断条件表达式 i<200
的值，如果为 true，就执行循环体语句，为第 i+1 个元素赋值。执行完循环体语句，执行 i++，更新循环
变量。然后再次对条件表达式 i<200 进行判断，开始下一次循环。
for 语句的使用相当灵活，循环变量既可以如上例中一样在 for 语句外面声明，然后在 for 语句中初
·19·
始化，也可以全部放在 for 语句外面定义并初始化，或者全部放在 for 语句中定义并初始化。如下面代
码所示。
public class ForExample {
public static void main(String[] args){
int[ ] mathScore = new int[200];        //声明大小为 200 的整型数组
//为数组 ForDemo 中的所有元素赋初值 60
int i = 0;                //定义循环变量
for(;i<200;i++){              //循环 200 次
mathScor[i] = 60;          //为数组中的每个元素赋初值 60
}
}
}
如上例所示，如果在 for 语句之前声明并初始化循环变量，也是可以的。此时，可以省略 for 语句
中的初始化表达式，但是分隔三个表达式的分号“；”不能省略，即使表达式为空。在 for 语句在，甚
至三个表达式都为空也是合法的，但是分号依然不能省略，如以下代码所示。
for(;;){
…
}
对循环变量的声明和初始化也可以放在 for 语句中，毕竟如果初始化变量仅仅用于 for 循环的话，
在 for 语句内声明更加合适。如下面示例：
public class ForExample {
public static void main(String[] args){
int[ ] mathScore = new int[200];        //声明大小为 200 的整型数组
//为数组中的所有元素赋初值 60
for(int i = 0;i<200;i++){          //循环 200 次
mathScor[i] = 60;          //为数组中的每个元素赋初值 60
}
}
}
对于循环变量 i 的改变，也可以放在循环体内，但是在 for 语句后面的括号中，用于分隔表达式的
分号不能省略，如下面代码所示。
for(int i = 0;i<200;){                //用于分隔表达式的分号不能省略
mathScor[i] = 60;              //为数组中的每个元素赋初值 60
i++；                  //改变循环变量的值
}
for 语句中的初始化表达式和迭代语句表达式，也可以是表达式列表，表达式之间用逗号分隔。如
下面代码所示。
for(int i = 0，j=0;i<200 && j < 100;i++,j--){
…
}
for 语句的流程图如图 4.7 所示。 
20
布尔表达式循环体语句 true
false
计算初始化表达式
迭代语句
图 4.7  while 语句的流程图
【例 4.16】使用 for 语句编写一个程序，求 100 （含 100）之内所有偶数的和。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 EvenExample3.java。
//  求 100（含 100）之内所有偶数的和
public class EvenExample3{
public static void main(String[] args){
int  sum=0;   
for(int number = 1;number <=100;number++){  //for 循环语句
if(number%2==0){        //判断 number 是否为偶数
sum = sum + number;    //如果 number 是偶数，就累加到 sum 变量上
}
} 
System.out.println(“100(含 100)之内所有偶数的和是：” + sum);
}
}
（2）使用如下命令编译和运行 EvenExample3.java 源程序。
javac EvenExample3.java
java EvenExample3
（3）程序输出结果如下。
100(含 100)之内所有偶数的和是：2550
可以看得出来，for 语句、while 语句和 do-while 语句通常情况下是等价的。到底在编程时使用哪一
种循环语句，更多地取决于读者自己的兴趣。
4.2.4   循环语句的嵌套
一个循环结构的循环体中还可以包含另一个完整的循环结构，这称为循环的嵌套。嵌套可以是多层
的，既在内嵌的循环结构内还可以再嵌套其他的循环结构。while 语句、do-while 语句以及 for 语句都可
以嵌套，而且它们之间也可以相互嵌套。下面是几种嵌套的语法形式。
（1）while 语句的嵌套。
while(条件表达式 1){
while(条件表达式 2){
…
}
}
（2）do-while 语句的嵌套。
do{
do{
… 
·21·
} while(条件表达式 1);
} while(条件表达式 2);
（3）for 语句的嵌套。
for(; ;){
for(; ;){
…
}
}
（4）for 循环与 while 循环嵌套。
for(; ;){
while(条件表达式){
…
}
}
（5）for 循环与 do-while 循环嵌套。
for(; ;){
do{
…
} while(条件表达式);
}
（6）while 循环与 for 循环的嵌套。
while(条件表达式){
for(; ;){
…
}
}
（7）do-while 循环与 for 循环的嵌套。
do{
for(; ;){
…
}
} while(条件表达式 1);
（8）do-while 循环与 while 循环的嵌套。
do{
while(条件表达式 1){
…
}
} while(条件表达式 2);
（9）while 循环与 do-while 循环的嵌套。
while(条件表达式 1){
do{
…
} while(条件表达式 2);
} 
【例 4.17】嵌套循环示例。使用循环的嵌套来处理数组的数组。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 NestedForExample.java。
public class NestedForExample{
public static void main(String[] args){ 
22
int  i , j;                //声明两个循环变量
int[][] arrays = new int[5][5];        //定义一个数组的数组
//为数组赋值 
for(i=0;i<5;i++){
for(j=0;j<5;j++){
arrays[i][j] = i + j ;        //第 i 行第 j 列的元素的值为 i 和 j 的和
}
} 
//输出数组中的元素值
for(i=0;i<5;i++){              //对行进行循环
for(j=0;j<5;j++){            //对每一行中的列进行循环
System.out.print (arrays[i][j] + “  “);  //输出数组第 i 行第 j 列元素的值
}
System.out.println(“”);        //换行
}
}
}
（2）使用如下的命令编译和运行 NestedForExample.java 源程序。
javac NestedForExample.java
java NestedForExample
（3）程序运行结果如图 4.8 所示。
图 4.8  二维数组输出结果（循环的嵌套）
在程序 NestedForExample.java 中，通过嵌套的双重循环 for 语句，改变数组的数组下标 i 和 j 的值，
依次为数组的元素赋值及输出数组中每个元素的值。
4.2.5   增强型 for 语句
对于简单的循环，Java 提供了一种 for-each 语法，又称为“增强型的 for 循环语句”。在某些情况
下，使用 for-each 语句更直观、更简洁，特别是用在读取数组或集合元素时。
foreach 语法如下所示。
for(数据类型  数据变量：数组或集合对象){
使用数据变量的循环体语句组
}
例如，对于数组元素的遍历，如果使用上节中讲到的 for 语句来遍历数组中的元素的话，通常代码
如下：
int[] arrays = {1,2,3,4,5};              //声明并初始化整型数组
for(int i=0;i<arrays.length;i++){            //使用 for 循环语句遍历数组元素 
·23·
System.out.pritnln(arrays[i]);
}
注意，上面用到了一个数组对象的属性：arrays.length。这在数组一节没有提到。在 Java 语言中，
是将数组看成对象的，对象有一个属性 length（属性的概念在类和对象一章中会讲到），代表数组的大
小，这样程序员无需知道数组的长度就可以遍历数组。
如果使用 for-each 语法，可以将上述代码改写为：
int[] arrays = {1,2,3,4,5};              //声明并初始化整型数组
for(int element : arrays){              //使用 foreach 循环语句遍历数组元素
System.out.pritnln(element);
}
每一次循环中，从数组 arrays 中依次取出的元素，会自动赋给变量 element，程序员不用自行判断
是否超出了数组的长度。注意，element 的类型必须与数组元素的数据类型相同。
增强型的 for 语句也可用于数组元素是对象的情形，请看下面的代码：
String[] names = {“张小明”,”刘芳”,”欧阳光明”};      //声明并初始化字符串类型数组
for(String name : names){             //使用 foreach 循环语句遍历数组元素
System.out.pritnln(name);
}
4.2.6   对数组进行排序
在编程的时候，经常需要对数组中的数据进行排序处理，例如价格从高到低排列、年龄从大到小排
列等，这需要使用到循环语句。请看下面对数组进行排序的示例。
【例 4.18】使用“冒泡排序法”对数组进行排序。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 SortExample.java：
public class SortExample{
public static void main(String[] args){
int  i , j;                  //定义循环变量 i 和 j
int[] arrays = {23,12,7,32,28};
int length = arrays.length;            //获取数组的长度，并保存在变量 length 中
System.out.println(“排序前，数组元素序列是：”);
for(i=0;i<length;i++){              //遍历数组当中的每一个元素，并输出
System.out.print(arrays[i] + “  “);
}
System.out.println(“ “);
//使用双重循环对数组排序 
for(i=0;i<length-1;i++){            //循环比较 length-1 趟
for(j=0;j<length-1-i;j++){          //对每一趟进行相邻元素的比较
int temp=0;
if(arrays[j]>arrays[j+1]){        //相邻两个元素进行互换
temp = arrays[j];
arrays[j] = arrays[j+1];
arrays[j+1] = temp;
}
}
}   
24
//输出排序后的数组元素序列
System.out.println(“排序以后，数组元素序列是：”);
for(i=0;i<length;i++){              //循环遍历输出数组元素的值
System.out.print(arrays[i] + “  “);
}
}
}
（2）使用如下的命令编译和运行 SortExample.java 源程序。
javac SortExample.java
java SortExample
（3）程序运行结果如下所示：
排序前,数组元素序列是：
23   12   7   32   28
排序以后,数组元素序列是：
7   12   23   28   32
在这个程序中，用冒泡排序法对数组进行了排序。所谓冒泡排序法，就是将相邻的元素依次进行比
较，如果前面的元素比后面的元素值大，就交换它们的值。这样每一轮排序下来，最大的元素会被交换
到数组的最后一个位置。这样一轮一轮比较和交换，就像冒泡一样。其原理如下图所示：
4.2.7   使用增强型 for 语句遍历数组的数组
通常情况下，遍历数组的数组（即数组的元素还是一个数组）使用双重 for 循环，但是也可以使用
增强型的 for 语句来遍历。使用前面讲到的 for 语句来遍历数组的数组，通常代码如下。
int i , j;
int[][] arrays = {{1,2,3},{4,5,6},{7,8,9}};
for(i=0;i<3;i++){                  //对行进行循环
for(j=0;j<3;j++){                //对每一行中的列进行循环
System.out.pritnln(arrays[i][j]);
}
}
数组的数组是这样的数组，它的元素又是数组。这样的话，就理解如何使用 for-each 语法进行存取
了。如果使用 for-each 语法，可以将上述代码改写为：
int i , j;
int[][] arrays = {{1,2,3},{4,5,6},{7,8,9}}; 
·25·
for(int[] row : arrays){              //循环遍历数组 arrays 的元素（同样是一个数组）
for(int element : row){            //循环元素数组中的每一个元素
System.out.pritnln(element);
} 
}
每一次外层循环中，从数组 arrays 中依次取出的元素，会自动赋给变量 row，这本身又是一个数组，
然后在内层循环中，再遍历数组 row，依次取出 row 中的每一个元素，赋给变量 element。注意， element
的类型必须与数组元素的数据类型相同。
在数组的数组包含不规则元素时，使用 for-each 语句特别有用。例如，对于如下不规则的数组
int[][] arrays = {
{1, 2},
{3, 4, 5},
{6, 7, 8, 9}
};
这个数组中每个元素本身又是一个的长度不相同的数组。要遍历这样的数组，使用 for 语句就会比
较麻烦，其代码如下所示：
int[][] arrays = {
{1, 2},
{3, 4, 5},
{6, 7, 8, 9}
};
for(int i=0; i<arrays.length; i++){
int[] array = arrays[i];
for(int j=0; j<array.length; j++){
System.out.print(array[j] + " ");
}
System.out.println();    //换行
}
如果使用 for-each 语句，则其代码如下所示：
int[][] arrays = {
{1, 2},
{3, 4, 5},
{6, 7, 8, 9}
};
for(int[] array : arrays){            
for(int element : array){
System.out.print(element + " ");
}
System.out.println();    //换行
}
4.3   分支语句
在前面的循环结构中，当循环条件不满足时或循环次数达到要求时，循环会退出。但是，有时候可
能需要在循环的执行过程中，当发生了某种情况之后，提前终止循环，这就需要分支语句 break、 continue
和 return。 
26
4.3.1   break 语句
在 switch 语句中，已经接触到了 break 语句。在 switch 语句中，break 语句的作用是终止 switch 语
句的执行，而整个程序继续执行后面的语句。用在循环结构中的 break 语句，也起同样的作用。
当在循环结构中执行到 break 语句时，它立即停止当前循环的执行，即提前结束循环，接着执行循
环下面的语句。break 语句的语法格式如下。
break;
同在 switch 中一样，直接在 break 后面加上分号“：”就可以了。如下面的代码片段所示。
final int PI = 3.14;        //定义一个常量 PI，代表圆周率
for(r=1;r<=10;r++){
area = PI * r * r ;      //求圆的面积，r 为半径
if(area>100)  break;
System.out.println(area);
}
这个代码片段计算 r=1 到 r=10 时的圆面积，直到圆的面积 area 大于 100 为止。从上面的 for 循环可
以看到：当 area>100 时，执行 break 语句，提前结束循环，即不再继续执行其余的几次循环。break 语
句不能用于循环语句和 switch 语句之外的任何其他语句中。
【例 4.19】编写程序，功能为在数组中查找是否有指定的整数，如果有，指出其所在位置。编写程
序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 BreakExample.java。 
public class BreakExample{
public static void main(String[] args){
int  i;                //指定变量出现的位置
int   number = 45;          //定义要查找的变量
//int number = 110;
int[ ] arrays = {23,45,2,8,67,258,94,1,18,45,1250};
boolean isFound = false;        //标志变量，初始值为 false
for(int element : arrays){        //遍历数组元素
if(element == number){      //如果某个元素的值与 number 变更的值相等
isFound = true;       //改变标志变量的值
break;          //中止循环，跳出 for 语句
}
} 
if(isFound){            //如果 isFound 值为 true，说明查找到了符合要求的数据
System.out.println(“找到了元素” + number);
}else{
System.out.println(“对不起，没有您要找的数据！”);
}
}
}
（2）使用如下命令编译和运行 BreakExample.java 源程序。
javac BreakExample.java
java BreakExample
（3）程序运行后输出结果如下。
“找到了元素 45” 
·27·
如果将变量 number 的值改为 110，那么输出的结果如下。
“对不起，没有您要找的数据！”
如果有嵌套的循环，而 break 语句在内层循环中被执行，那么程序将跳出内层循环，从下一个外层
循环开始执行。
【例 4.20】嵌套循环中 break 语句应用示例。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 BreakExample2.java。
public class BreakExample2{
public static void main(String[] args){
for(int i=0;i<3;i++){
System.out.println(“Pass “ + i + “: ”);
for(int j=0;j<100;j++){
if(j==10)   break;        //如果变量 j 等于 10，终止内层循环
System.out.print(j + “  “);
}
System.out.println( );          //换行
}
System.out.println(“循环结束.”);
}
}
（2）使用如下命令编译和运行 BreakExample2.java 源程序。
javac BreakExample2.java
java BreakExample2
（3）程序运行后输出结果如下。
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
循环结束
从中可以看出，在内部循环中的 break 语句仅仅终止了该循环，外部的循环不受影响。
使用 break 需要注意以下几点：
  一个循环中可以有一个以上的 break 语句，但是太多的 break 语句会破坏代码结构。
  switch 语句中的 break 仅仅影响该 switch 语句，而不会影响其中的任何循环。
  break 不是被设计来提供一种正常的循环终止的方法。循环的条件语句是专门用来终止循环的。
只有在某类特殊的情况下，才用 break 语句来取消一个循环。
从上面的示例中可以看出，在内层的 break 语句只是终止它所在的循环。如果当某种特殊情况发生
时，想同时终止所有的内外层循环，即直接终止所有的循环，那么需要在每一层中都使用 break 语句。
例如下面的代码片段所示。
for(int i=0;i<3;i++){
boolean flag = false;
for(int j=0;j<100;j++){
if(j==10){  
flag = true;
break;        //如果变量 j 等于 10，终止内层循环
}
if(flag)   break;        //如果终止了内层循环，那么外层循环也终止
}
} 
28
上述代码并无太大的实际意义，它仅仅展示了如果要同时跳出两层嵌套的循环时，该如何做。看上
去还是比较麻烦的，设想一下，如果嵌套的不是两层，而是五层，那么代码如何写？显然，更麻烦！幸
好的是，Java 语言提供了一种扩展的 break 语句，称为“标签 break”。标签 break 可以终止一个或几个
代码块，其语法格式如下。
break  标签名称；
这里，标签名称是标识代码块的标签。当这种形式的 break 执行时，控制被传递出指定的代码块。
被加标签的代码块必须包围 break 语句。请看下面的示例，注意其中的注释处的标签。
【例 4.21】标签 break 语句应用示例。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 BreakExample3.java：
public class BreakExample3{
public static void main(String[] args){
outer:                  //定义标签，标签名称为 outer
for(int i=0;i<3;i++){
System.out.print(“Pass “ + i + “: ”);
for(int j=0;j<100;j++){
if(j==10)   break outer;        //如果变量 j 等于 10，终止所有循环
System.out.print(j + “  “);
}
System.out.println(“这个语句不会被执行”);  //换行
}
System.out.println(“循环结束.”);
}
}
上面的代码中，定义了一个标签 outer。标签可以是任何合法有效的 Java 标识符，后跟一个冒号。
一旦给一个块加上标签以后，就可以使用这个标签作为 break 语句的对象了。
（2）使用如下命令编译和运行 BreakExample3.java 源程序。
javac BreakExample3.java
java BreakExample3
（3）程序运行后输出结果如下。
Pass 0: 0   1   2   3   4   5   6   7   8   9   循环结束
可以看到，当内部循环退到外部循环时，两个循环都被终止了。
标签 break 还可以用于任何的代码块或嵌套代码块，它会使程序的执行在加标签的块的结尾处重新
开始。例如，下面的程序示例了 3 个嵌套块，每一个都有它自己的标签。其中的标签 break 语句使执行
流程向前跳，跳过了 2 个 println()语句。
【例 4.22】嵌套的标签 break 语句应用示例。编写程序的步骤如下。
（1）打开记事本，编写程序代码如下，并保存为 BreakExample4.java。
public class BreakExample4{
public static void main(String[] args){
boolean flag = true;
first:                  //定义标签，标签名称为 first
{
second:              //定义嵌套的标签，标签名称为 second
{
third:              //定义第三层嵌套的标签，标签名称为 third
{
System.out.println(“这里是第三层，执行 break 之前.”); 
·29·
if(flag){
break second;      //跳转到第二层循环结束处
}
System.out.println(“这条语句不会被执行”);
}
System.out.println(“这里是第二层，这一句也不会被执行。”);
}
System.out.println(“这里是第一层，这一句会被执行。”);
}
}
}
（2）使用如下命令编译和运行 BreakExample4.java 源程序。
javac BreakExample4.java
java BreakExample4
（3）程序运行后输出结果如图 4.10 所示。
图 4.10  标签 break 语句的使用
在程序 BreakExample4.java 中，当条件 flag 为 true 时，就会执行“break second”语句，跳转到标签
second 所代表的语句块外，因此该语句及 second 标签所标识的语句块后面的语句都不会被执行。
4.3.2   continue 语句
如果需要提前结束本次循环，立即开始下一轮循环，而不是终止整个循环的执行，可以使用 Java
提供的 continue 语句。continue 语句的语法形式如下。
continue;
continue 应用在 for、while、do-while 等循环语句中，其作用为结束本次循环，即跳过循环体中下面
尚未执行的语句，接着进行下一次是否执行循环的判断。
【例 4.23】continue 跳转语句应用示例。
//把 100~200 之间的不能被 3 整除的数输出
public class ContinueExample{
public static void main(String[] args){
int   n;                //声明变量 n
for(n=100;n<=200;n++){          //从 100 循环到 200
if(n%3 ==0){            //如果整数 n 能被 3 整除
continue;            //则结束本次循环，开始下一循环
}
System.out.print (n + “ “);        //如果不能被 3 整除，则输出 n 的值
}
}
} 
30
在上面的程序中，当整数 n 能被 3 整除时，执行 continue 语句，结束本次循环（即跳过后面的输出
语句）。只有当 n 不能被 3 整除时才执行后面的输出函数。
continue 和 break 语句都是跳出循环，但它们的作用是不同的。continue 语句只结束本次循环，而不
是终止整个循环的执行。而 break 语句则是结束整个循环过程，不再判断执行循环的条件是否成立。如
果有以下两个循环结构：
  循环结构 1
while(表达式 1){
…
if(表达式 2)   break;
…
}
  循环结构 2
while(表达式 1){
…
if(表达式 2)   continue;
…
}
那么，循环结构 1 的流程图如图 4.11 所示，而循环结构 2 的流程图如图 4.12 所示。请注意两图中
当“表达式 2”为 true 时流程的转向。
表达式1
表达式2
while循环的
下一语句
true
false
true
false
表达式1
表达式2
while循环的
下一语句
true
false
true
false
图 4.11  使用 break 语句的流程图                 图 4.12  使用 continue 语句的流程图
4.3.3   return 语句
最后一个分支语句是 return 语句。使用 return 语句从当前方法中退出，程序控制流返回到该方法被
调用的位置。return 语句有两种形式：返回一个值或不返回值。要返回一个值，只需将一个值或运算结
果为值的表达式放在 return 关键字后面即可，如下所示：
return count;
返回值的数据类型必须与方法声明的返回值数据类型保持一致（相同或为其子类型）。如果一个方
法声明中使用 void 关键字，那么说明该方法不返回值，这时使用如下的语句： 
·31·
return;
关于方法和方法声明，我们将在“类和对象”一章中详细讲解。
4.4   实例 
循环结构既有 while、do-while 语句，也有 for 和 for-each 语句，使用起来非常灵活。而且，在很多
情况下，这几种循环结构是可以相互替代的。本节就通过译密码和打印九九乘法表两个实例程序的讲解，
帮助读者学习和掌握循环结构在程序中的应用。
4.4.1   实例 1：译密码
所谓译密码，是指为了通信保密，按一定规律，将通信内容转换成密码，收到加密内容的收信人再
按约定的规律将其译回原文。本实例中，将按以下规律将通信内容转换成密码：
将字母 A 变成字母 E，a 变成 e，即将原文中的字母变成其后的第 4 个字母。而 W 变成 A，X 变成
B， Y 变成 C， Z 变成 D，即循环加密。字母按上述规律转换，非字母字符不变。例如“love”变成“pszi”。
下面是加密程序的代码。
//通信内容简单加密
public class Encrypt{
public static void main(String[] args){
char[ ] message = {„I‟,‟ „,‟l‟,‟o‟,‟v‟,‟e‟,‟ „,‟y‟,‟o‟,‟u‟,‟!‟};  //定义要加密的字符数组
System.out.println(“加密之前，原文内容为：”);    //先输出加密之前的内容
for(int i=0;i<message.length;i++){        //遍历字符数组
System.out.print(message[i]);        //输出数组中每一个字符
}
System.out.println( );
System.out.println(“加密之后，密文内容为：”);
for(int i=0;i<message.length;i++){        //遍历字符数组的长度
int character = message[i];        //获取字符串中第 i+1 个字符
//如果为字符，则进行转换
if((character >=‟a‟ && character<=‟z‟) || (character >=‟A‟ && character<=‟Z‟)){
character = character + 4;        //每个字符的 ASCII 码值加 4
//如果换算以后的字符超出了字母表的范围，则从头再循环计算
if((character>‟Z‟ && character<=‟Z‟+4) || character>‟z‟)
character = character - 26;
}
System.out.print((char)character);
}
}
}
程序中，对原始字符的处理办法是：先判定它是否大写字母或小写字母，若是，则将其值加 4（变
成其后的第 4 个字母）。如果加 4 以后字符值大于‘Z’或‘z’，则表示原来的字母在 V（或 v）之后，
32
就将它转换为 A~D（或 a~d）之一。办法是使其减 26（请查阅 Java 的字符编码表 Unicode 表）。注意
在最后输出时，要使用强制类型转换，将整型转换为字符型输出。
编译并运行 Encrypt.java，输出结果如下所示：
加密之前，原文内容为：
I love you!
加密之后，密文内容为：
M pszi csy!
按照同样的规律，可以写出相应的解码程序，如下所示。
//通信内容解密
public class Decode{
public static void main(String[] args){
char[ ] message = {„M‟,‟ „,‟p‟,‟s‟,‟z‟,‟i‟,‟ „,‟c‟,‟s‟,‟y‟,‟!‟};
System.out.println(“解密之前，密文内容为：”);
for(int i=0;i<message.length;i++){      //循环输出字符数组中的每一个字符
System.out.print(message[i]);
}
System.out.println( );
System.out.println(“解密之后，原文内容为：”);
for(int i=0;i<message.length;i++){      //遍历字符数组中的每一个字符
int character = message[i];      //获取字符串中第 i+1 个字符
//判断字符所属类型
if((character >=‟a‟ && character<=‟z‟) || (character >=‟A‟ && character<=‟Z‟)){
character = character - 4;
if((character<=‟a‟ && character>=‟a‟-4) || character<‟A‟)
character = character + 26;
}
System.out.print((char)character);
}
}
}
编译并运行 Decode.java，输出结果如下所示：
解密之前，密文内容为：
M pszi csy!
解密之后，原文内容为：
I love you!
4.4.2   实例 2：打印九九乘法表
九九乘法表是每个人小时候都要熟读并背诵的。九九乘法表既有行又有列，因此下面这个程序，使
用双重循环来实现打印输出一个九九乘法表。
//打印九九乘法表
public class MultiTable{
public static void main(String[] args){ 
·33·
for(int i=1;i<10;i++){              //循环行
for(int j=1;j<=i;j++){            //循环列
System.out.print(j + “*” + i + “=” + i*j);
if(i*j<10)              //如果乘法之和为个位数
System.out.print(“   “);      //多输出一个空格，使输出结果排列整齐
else
System.out.print(“  “);      //少输出一个空格
}
System.out.println( );
}
}
}
编译并运行 MultiTable.java，输出结果如下所示：
1*1=1
1*2=2    2*2=4
1*3=3    2*3=6    3*3=9
1*4=4    2*4=8    3*4=12   4*4=16
1*5=5    2*5=10   3*5=15   4*5=20   5*5=25
1*6=6    2*6=12   3*6=18   4*6=24   5*6=30   6*6=36
1*7=7    2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49
1*8=8    2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64
1*9=9    2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81
在程序 MultiTable 中，注意嵌套的 for 循环的循环条件。因为这里要输出一个三角形的九九乘法表，
所以第二层 for 循环的循环条件为 j<=i，即列索引值要小于等于行索引值，只有这样，才能在行和列索
引值相等时就换行。另外，为了输出结果的美观整齐，当乘积为个位数时，后面要多输出一个空格。
4.4.3   实例 3：打印复杂图形
在下面这个示例程序中，打印如下图所示的图形：
要实现上述输出效果，首先分析输出结果。通过分析发现，在这个结果中，共输出 8 行数据，在输
出的每一行中，假设当前行是第 i 行（i 从 0 开始），那么有着如下的规律：
（1）  首先输出 7-i 个空格
（2）  再输出 2*i+1 个数字（先升序再降序输出数字）
（3）  最后再输出 7-i 个空格
根据上面的分析，实现代码如下：
public class PrintNumber {
public static void main(String[] args) { 
34
for (int i = 0; i < 8; i++) {
//1.先打印(7-i)个空格
for (int j = 0; j < (7 - i); j++) {
System.out.print("     ");
}
//2.再打印(2*i+1)个数字
//  2.1 先打印一个 1，以及(i)个升序数列
int number = 1;
System.out.print("   " + number + " ");
for (int j = 0; j < i; j++) {
number = number*2;
if(number<10){
System.out.print("   " + number + " ");
}else if(number<100){
System.out.print(" " + number + " ");
}else{
System.out.print(number + " ");
}                
}
//  2.2 再打印(i)个降序数列
for (int j = 0; j < i; j++) {
number = number/2;
if(number<10){
System.out.print("   " + number + " ");
}else if(number<100){
System.out.print(" " + number + " ");
}else{
System.out.print(number + " ");
}                
}
//3.最后再打印(7-i)个空格
for (int j = 0; j < (7 - i); j++) {
System.out.print("     ");
}
System.out.println();
}
}
}
4.5   小结
本章深入介绍了有关程序流程控制的语句，主要包括条件语句、循环语句和跳转语句。 
·35·
其中 if-then 语句是所有控制流程语句中最基本的语句，它告诉程序，只有当一个特定的条件为 true
时，才执行相应的代码块。而 if-then-else 语句则提供了两个可能的程序执行流程。不象 if-then 和
if-then-else 语句，switch 语句提供了超过两个以后的可能的程序执行流程。需要注意的时，从 JDK 7 开
始，switch 语句后面的条件表达式可以是字符串。
循环语句中，当某个特定的条件为 true 时，会重复执行一个代码块。其中 do-while 和 while 语句的
区别在于 do-while 语句是“先执行循环体语句，后进行条件判断”，而 while 语句是“先执行条件判断，
后执行循环体语句”。因此，do-while 语句即使在条件一开始就不成立的情况下，也至少会执行一次循
环体语句。for 语句与 while 和 do-while 语句等价，但是使用起来更加灵活，即可以按条件执行循环，也
可以按范围或次数执行循环。通过使用循环来遍历集合或数组。