- 零基础学Java（第4版）
- 常建功 陈浩 黄淼等编著
- 202字
- 2022-09-20 01:54:33
第4章 程序设计中的流程控制
任何一门语言都需要基本的流程控制语句，其思想也符合人类判断问题或做事的逻辑过程。什么是流程控制呢？流程就是做一件事情的顺序，或者说是次序。在程序设计中，流程就是要完成一个功能，而流程控制则是指如何在程序设计中控制完成某种功能的次序。本章将通过大量的实例，为读者讲解如何在程序中设计好流程控制。
本章重点：
□ Java语言的编程风格。
□ 条件语句、分支语句和循环语句。
□ 中断、继续、返回语句。
4.1 编程风格
本章开始接触到编写Java程序代码，有一点必须强调，那就是编程风格的问题，虽然其不影响程序代码段的运行，但对于程序的可读性起着重要的作用。自己编出的程序要让别人看懂，首先在排版方面要非常注意，下面将探讨编程风格的问题。
其实每个人、每个软件开发公司的编程风格都不一样。一个人编写的程序代码就应该能让别人看懂，甚至是过了很长时间，自己也要看得懂，否则这个程序就成了一个没法扩展的程序。编程风格是指编程时的格式，让程序看上去就很有层次感。下面通过一些例子说明编程风格的重要性。
【实例4-1】先来看第一个例子。
01 public class math
02 {
03 public static void main(String[] args)
04 {
05 int x=12;
06 double y=12.3d; //定义double类型
07 void print() //关于打印方法
08 {
09 char a='a';
10 System.out.println(a);
11 }
12 System.out.println(x+y); //关于输出方法
13 }
14 }
【代码说明】上面程序段的整个排版看起来是否很舒服，并且层次感很强？是否一眼看上去就知道整个程序架构？这里的关键在于缩排，缩排也称为跳格。
上面程序段采用的是跳格形式：“public class math”是顶格的，接着主运行程序前跳4个空格，在主运行程序内的运行代码段一律跳8个空格，而在主运行程序方法内的代码前，再跳4个空格。这样整个程序的所属关系就很明显了。主运行程序从属于math类，其余的都属于主运行程序，而在主运行程序方法内的代码段又属于此方法。规律就是空格多的代码从属于空格少的代码。
【实例4-2】除了空格外，空行也是必要的。为什么要空行呢？先看下面的程序代码，再来仔细分析。
01 public class math {
02 public static void main(String[] args)
03 {
04 int x=12;
05 int y=23;
06 void print() //打印方法
07 {
08 …
09 }
10
11 void view() //显示方法
12 {
13 …
14 }
15 }
16 }
【代码说明】在print方法与view方法之间有个空行（第10行），使用空行区分不同功能的模块。print方法所完成的功能与view所完成的功能不一样，所以使用空行将它们分开，这样更增加了程序的可读性。
另外，需要注意的是方法或属性的命名。这些名字应该有含义，最好有规律。不要只使用“a”、“b”这种通用变量，可以适当根据变量或函数的功能为其命名。上面的“print”，其他程序员一看就知道这个方法是有关打印或输出的函数。再如变量名“name”，一看就知道是有关名字的变量。所以命名要有意义，否则程序的可读性不强。
还有一点是有关注释的。在每个方法的方法名旁边，应该添加一些注释，同时在一段程序完成之后，也要对程序的功能及如何操作做简单的描述。
只要做到以上几点，这个程序就是易读的。即使经过很长时间后再来读程序也会一目了然。
4.2 条件语句
在现实生活中，经常听人说：如果某人发财了，某人就会做什么。其实这就是程序设计中所说的条件语句。例如“如果……就……”、“否则……”，当然这只是很简单的条件语句，在真正的程序设计中，使用的条件语句要比这复杂得多。
4.2.1 简单条件语句
在程序设计中，条件语句的标准格式如下：
if(条件)
{
目的一;
}
else
{
目的二;
}
【实例4-3】掌握格式后，先看一个简单的程序段。
01 public class control {
02 public static void main(String[] args) {
03 int a = 20;
04 int b = 30;
05 if (a > b) { //将整型变量a,b的大小比较得出的布尔型变量作为条件语句的条件
06 System.out.println("很幸运！");
07 } else {
08 System.out.println("很开心");
09 }
10 }
11 }
【代码说明】因为“a=20”而“b=30”，所以“a<b”。在条件语句中，程序代码的意思是，如果“a>b”，就输出“很幸运！”，如果“a<b”，就输出“很开心”，所以程序的输出结果就是“很开心！”。
【运行效果】
很开心！
注意
条件表达式是一个关系表达式，其结果是布尔型数据。换句话解释上面的程序段：如果“a>b”是真，就输出“很幸运！”，否则输出“很开心！”。
4.2.2 最简单的条件语句
在条件语句的程序设计中，有一种最简单的条件语句，如下所示：
if(条件) 目的;
如果有很多的目的，也可以采取下面的形式：
if(条件)
{
目的一;
目的二;
目的三;
目的四;
}
【实例4-4】下面看一个有关这种类型条件语句的例子。
01 public class control1
02 {
03 public static void main(String[] args)
04 {
05 int salary=10000; //变量初始化
06 if (salary>500) //条件判断
07 {
08 System.out.println("想请吃饭！");
09 System.out.println("想请唱歌！");
10 System.out.println("想请喝酒！");
11 }
12
13 }
14 }
【代码说明】条件语句中判断“salary>500”是否为真，如果是真就输出“想请吃饭！想请唱歌！想请喝酒！”，如果是假，就什么都不做。在程序中“salary=10000”，满足“salary>500”，条件为真，所以输出以上三句话。
【运行效果】
想请吃饭！ 想请唱歌！ 想请喝酒！
注意
在有多个目的的程序段中，一般按顺序执行，即先执行目的一，再执行目的二，最后执行目的三，依次执行。
4.2.3 适应多条件的条件语句
如果出现多种不同的条件，应该如何处理呢？可以使用条件语句中的复杂型，其结构如下：
if (条件1)
{
目的1;
}
else if (条件2)
{
目的2;
}
else if (条件3)
{
目的4;
}
else
{
不满足以上所有条件，如何办;
}
【实例4-5】根据以上结构，学习有关这种复杂条件语句的实例，代码如下所示：
01 public class control2 {
02 public static void main(String[] args) {
03 int achievement = 85;
04 //当achievement等于100，就奖励一台笔记本电脑
05 if (achievement == 100) {
06 System.out.println("奖励一台笔记本电脑");
07 } else if ((achievement >= 90) && (achievement < 100)) {
08 //当achievement大于90小于100，就奖励一个MP4
09 System.out.println("奖励一个MP4");
10 } else if ((achievement >= 80) && (achievement < 90)) {
11 //当achievement大于80小于90，就奖励一块网卡
12 System.out.println("奖励一块网卡");
13 } else if ((achievement >= 60) && (achievement < 80)) {
14 //当achievement大于60小于80，不给予奖励
15 System.out.println("不给予任何奖励");
16 } else {
17 //当achievement小于60，放假回学校补习
18 System.out.println("放假回学校补习");
19 }
20 }
21 }
【代码说明】从上述代码可以看出，当有多个不同的条件存在时，处理的结果就不一样。成绩在大于80分小于90分之内，就可以奖励一块网卡；而成绩大于90分小于100分，则奖励一个MP4。在此程序中，初始成绩是85分，所以处理的结果就是奖励一块网卡。
【运行效果】
奖励一块网卡
条件语句已经基本介绍完毕，很重要的一点就是，在程序设计的时候，思路一定要清晰，如何才能有很清晰的思路呢？那就是绘制流程图。流程图就是：在程序开发前，为了能够使思路更加清晰，而将整个程序执行的顺序流程绘制出来。图4-1为一个有关条件语句的通用流程图。
图4-1 if条件语句流程图
将上面的程序段作为一个实例，绘制其基本的流程图，如图4-2所示。鉴于页面的版面，这里只给出了4种条件，并没有完全体现出上面案例的5种条件，读者可自己画一个完整的流程图。
图4-2 实例4-5的条件流程图
针对最复杂的条件语句，在程序设计中，有一种分支语句可以代替复杂条件语句。在实际程序开发过程中，使用条件语句类型比较多的是标准型，而复杂型的一般用分支语句来代替。当然也可以使用复杂型的条件语句。为了与实战结合，下面以一个稍微复杂的程序段为例。
【实例4-6】条件：设计一个程序，用于计算语文（90）、英语（75）、数学（90）、艺术（85）四门功课的平均分，并对此学生进行评价。
在编写程序之前要先绘制流程图，这样编程的思路就会非常清晰，本例流程图如图4-3所示。
图4-3 实例4-6的条件流程图
根据以上的流程图编写程序，程序代码段如下：
01 public class control3 {
02 public static void main(String[] args) {
03 //创建成员变量
04 int Chinese = 90;
05 int English = 75;
06 int Math = 90;
07 int Art = 85;
08 //获取平均值
09 double Avg = (Chinese + English + Math + Art) / 4;
10 if ((Avg > 90) && (Avg <= 100)) {
11 //如果是大于90小于等于100则是优秀
12 System.out.println("这个学生的所有功课的平均分是：" + Avg);
13 System.out.println("这个学生的成绩应得A，是优秀");
14 } else if ((Avg > 80) && (Avg <= 90)) {
15 //如果是大于80小于等于90则是良好
16 System.out.println("这个学生的所有功课的平均分是：" + Avg);
17 System.out.println("这个学生的成绩应得B，是良好");
18 } else if ((Avg > 70) && (Avg <= 80)) {
19 //如果是大于70小于等于80则是良
20 System.out.println("这个学生的所有功课的平均分是：" + Avg);
21 System.out.println("这个学生的成绩应得C，是良");
22 } else if ((Avg > 60) && (Avg <= 70)) {
23 //如果是大于60小于等于70则是合格
24 System.out.println("这个学生的所有功课的平均分是：" + Avg);
25 System.out.println("这个学生的成绩应得D，是合格");
26 } else {
27 //如果小于60则是不合格
28 System.out.println("这个学生的所有功课的平均分是：" + Avg);
29 System.out.println("这个学生的成绩应得E，是不合格");
30 }
31 }
32 }
【代码说明】第10～32行是复杂型的条件语句，判断了5种情况下不同的输出结果。第9行定义的是double变量，表示计算后的平均值。
【运行效果】
这个学生的所有功课的平均分是：85.0 这个学生的成绩应得B,是良好
4.2.4 嵌套条件语句
if嵌套语句也是经常使用的多分支判断语句，在一次判断之后又有新一层的判断，接着又有一层判断，逐渐深入，达到实现复杂判断的目的，这种多层次判断相当于多条件判断，在满足几个条件后再执行适当的语句。if嵌套语句的格式是：
if(条件1)
if(条件2)
if(条件3)
执行语句1;
在if(条件1)成立的情况下继续判断直到if(条件3)也成立，再执行语句1。如果其中有一个条件不满足，则跳出该if嵌套语句，继续执行嵌套语句之外的代码。
4.2.5 如何使用条件语句
使用条件语句需要注意以下几点。
1）应该绘制流程图，使编程时的思路更加清晰。
2）编程时，在最简单形式的条件语句中，可以不使用大括号，因为它不会产生混淆。但建议无论是哪种形式的条件语句，都应该使用大括号。
4.3 循环语句
循环语句在程序设计中有什么作用呢？本节将通过一个具体功能（计算数字1连加10次1后的结果）来演示。
【实例4-7】下面先看一段简单的程序段，再来看看使用循环语句编写程序的好处在哪里。
01 ///将x连续加1加10次
02 public class control4
03 {
04 public static void main(String[] args)
05 { //连续自加10次
06 int x=1; //x初始化为1
07 x=x+1;
08 x=x+1;
09 x=x+1;
10 x=x+1;
11 x=x+1;
12 x=x+1;
13 x=x+1;
14 x=x+1;
15 x=x+1;
16 x=x+1;
17 System.out.println(x); //l输出x最终的结果
18 }
19 }
【代码说明】代码的含义是让变量“x”连续加1共加10次。如果想要实现加1加100次，那要让“x=x+1”这个表达式重复100次。
【运行效果】
11
这样庞大的程序段所要完成的功能，不过是一个很简单的相加功能。为了解决这类问题，程序设计中引入了循环语句。循环语句共有3种常见的形式：for语句、while语句和do…while语句。下面将逐个详细介绍。
4.3.1 for循环语句
让初始值为1的变量“x”连续加1共加10次，可以直接编写10次“x=x+1;”语句，但是如果要加100呢？这时肯定不能编写100次“x=x+1;”语句。为了解决该问题，可以使用for循环语句。
for循环语句的基本结构如下：
for(初始化表达式；判断表达式；递增（递减）表达式)
{
执行语句
}
下面详细解释for循环语句中各个子项的意义。
1）初始化表达式：初始化表达式的意义在于定义循环之前变量的值是多少，如果没有这一项，就不知道应该从哪个值开始循环。
2）判断表达式：判断表达式的作用在于规定循环的终点。如果没有判断表达式，那么此循环就成了死循环。
3）递增（递减）表达式：这一项规定每执行一次程序，变量以多少增量或减量进行变化。
注意
一定要注意递增（递减）表达式中可以有多个表达式，它们以逗号间隔，而不是分号。
【实例4-8】使用for语句，来修改上一小节的程序段。
01 public class control5
02 {
03 public static void main(String[] args)
04 {
05 int x;
06 int n=10; //定义了循环的次数
07 for( x=1;n>0;n--,x++) //通过循环实现连续加1共10次
08 {System.out.println(x);}
09 }
10 }
【代码说明】上述代码中，第5～8行共4句代码完成了前面程序段里12句代码所实现的事情。
【运行效果】
1 2 3 4 5 6 7 8 9 10
【实例4-9】如果前面的程序段需要连续加1加100次，则参考下面的程序段。
01 public class control6
02 {
03 public static void main(String[] args)
04 {
05 int x;
06 int n=100; //定义了循环的次数
07 for(x=1;n>0;n--,x++) //实现循环
08 System.out.println(x);
09 }
10 }
【代码说明】在这个程序段里，使用第5～8行共4句代码可以解决程序段中102句代码所实现的问题，这就是循环语句的优势。
【运行效果】
1 2 3 … 100
其实也可以利用在条件判断语句中提到的流程图来编写程序，在流程图中可以看出程序执行的顺序，如图4-4所示。
图4-4 for循环语句流程图
【实例4-10】下面再看一个九九乘法表的程序段。先来绘制流程图，如图4-5所示。
图4-5 九九乘法表流程图
根据流程图，使用循环语句实现乘法口诀表。
01 ///这是一个二重for循环语句
02 public class control7
03 {
04 public static void main(String[] args)
05 {
06 for(int x=2;x<10;x++) //输出8行
07 {
08 for(int y=1;y<10;y++) //输出9列
09 {
10 System.out.print(x+"＊"+y+"="+(x＊y));
11 System.out.print("");
12 }
13 System.out.println("");
14 }
15 }
16 }
【代码说明】第6～14行是外围的for循环，第8～12行是一个嵌入在外围循环中的循环，这样的形式我们称之为嵌套循环。为什么要使用二重循环呢？因为它涉及两个变化的量。在一个程序里，有多少个不同的变量，就要使用多少个for循环，当然也不是非常绝对的。
【运行效果】
2＊1=2 2＊2=4 2＊3=6 2＊4=8 2＊5=10 2＊6=12 2＊7=14 2＊8=16 2＊9=18 3＊1=3 3＊2=6 3＊3=9 3＊4=12 3＊5=15 3＊6=18 3＊7=21 3＊8=24 3＊9=27 4＊1=4 4＊2=8 4＊3=12 4＊4=16 4＊5=20 4＊6=24 4＊7=28 4＊8=32 4＊9=36 5＊1=5 5＊2=10 5＊3=15 5＊4=20 5＊5=25 5＊6=30 5＊7=35 5＊8=40 4＊9=36 6＊1=6 6＊2=12 6＊3=18 6＊4=24 6＊5=30 6＊6=36 6＊7=42 6＊8=48 6＊9=54 7＊1=7 7＊2=14 7＊3=21 7＊4=28 7＊5=35 7＊6=42 7＊7=49 7＊8=56 7＊9=63 8＊1=8 8＊2=16 8＊3=24 8＊4=32 8＊5=40 8＊6=48 8＊7=56 8＊8=64 8＊9=72 9＊1=9 9＊2=18 9＊3=27 9＊4=36 9＊5=45 9＊6=54 9＊7=63 9＊8=72 9＊9=81
在上面的程序段中，使用了2层嵌套的for语句。其实真正复杂的程序段中，可能会出现4层嵌套的for语句，这要在实践中慢慢体会。
通过上面的内容，可以发现循环流程关键字for的语法比较复杂。为了改变该现象，便出现了关于for循环的另一种语法（增强版for循环），该方式可以简化for循环的书写。
增强版for循环的基本格式如下：
for(type 变量名：集合变量名){
}
在上述基本格式中，迭代变量必须在方法体中定义，集合变量除了可以是数组，还可以是实现了Iterable接口的集合类。
下面将通过修改VariableArgument.java类来演示增强版的for，具体内容如下所示：
01 public class VariableArgument {
02 public static int add(int... xs) {
03 int sum = 0;
04 for (int x : xs) { //增强版for循环
05 sum = sum + x;
06 }
07 return sum; //返回变量sum
08 }
09 }
【代码说明】上述代码中通过for(int x : xs)语句代替了for (int x = 0; x < xs.length; x++)语句，实现了相应的循序迭代功能，即运行VariableArgumentTest.java类，会显示出正确的信息。
4.3.2 while循环
在英文中“while”这个词的意思是“当”，而在Java程序设计中，也可以将其理解为“当”。其语法结构如下。
while (条件)
{
目的一;
目的二;
…
}
当满足某种条件，就执行“目的一”、“目的二”等，while语句的循环体在{}中。
【实例4-11】下面看一段程序段，通过分析它，让读者更加清楚while循环语句。
01 //通过判断y是否大于0
02 //如果y大于0的话则将计费次数减1，x加1
03 public class control8
04 {
05 public static void main(String[] args) {
06 int x=0;
07 int y=100;
08 int sum=0;
09 while(y>0) //while循环
10 {
11 x=x+1;
12 y--; //值自减
13 sum+=x;
14 }
15 System.out.println(sum); //输出和
16 }
17 }
【代码说明】这个程序段是将数字从1一直加到100，条件是只要y大于0，就会执行大括号里的语句。y初始值是100，满足条件，所以执行大括号的表达式。先将x+1赋给x，因为x的初始值是0，所以x从1开始计数，然后，将y自减1，此时y变成了99，将sum加上x赋给sum。此时，执行语句结束了，又会回到小括号的条件，最后再比较y=99是否大于0，如果大于0，再继续执行大括号里的语句。
一旦y自减到小于等于0，则将结束执行大括号里的语句，开始执行大括号外的语句。在上面的程序段中，y就相当于一个计数器。
【运行效果】
5050
同样，在编写while语句时，要先绘制流程图，根据流程图再来编写程序段，整个思路就会很清晰了。下面先看while的流程图，如图4-6所示。
图4-6 while循环语句流程图
其实while语句很简单，根据这个流程图，就可以思路清晰地编写程序段。下面针对上面的程序段来绘制流程图，如图4-7所示。
图4-7 实例4-11的循环流程图
看了这个流程图，会发现按照流程图来编写程序简单多了。为了巩固以上所述，再看一个例子。
【实例4-12】试编写程序实现输出1～100间的整数，并且此整数必须满足：它是3的倍数，但不是5的倍数，也不是9的倍数。针对这个例子，先来绘制一个流程图，如图4-8所示。
图4-8 输出特殊数字的循环流程图
根据流程图，现在来编写程序段。
01 public class control9 {
02 public static void main(String[] args) {
03 int x = 1;
04 //判断是否在100以内，并且是3的倍数
05 while (((3 * x > 1) && (3 * x < 100))) {
06 if ((3 * x) % 5 != 0) { //然后再判断这些数是否不是5的倍数
07 if ((3 * x) % 9 != 0) { //最后判断这些数是否不是9的倍数
08 System.out.println(3 ＊ x);
09 }
10 }
11 x++;
12 }
13 }
14 }
【代码说明】第5行是一个循环判断条件，判断是否在100以内，并且是3的倍数。第6行是一个条件语句，判断这些数是否不是5的倍数。第7行也是一个条件语句，判断这些数是否不是9的倍数。
【运行效果】
3 6 12 21 24 33 39 42 48 51 57 66 69 78 84 87 93 96
按照先绘制流程图，后编写程序的步骤，会显得思路更清晰。其实从上面的程序段中，可以总结一点：当由多个条件形成循环条件时，可以选择其中一个作为循环条件，而剩下的条件可以在循环体中作为条件语句。
4.3.3 do…while语句
在学习do…while语句之前，先清楚while语句是如何工作的。while语句是先进行条件判断，再执行大括号内的循环体。do…while语句与while语句不同的是，它先执行大括号内的循环体，再判断条件，如果条件不满足，下次不再执行循环体。也就是说，在判断条件之前，就已经执行大括号内的循环体。
do…while循环语句格式为：
do
执行代码;
while(布尔表达式)
【实例4-13】下面先看一个程序段。
01 public class control10 {
02 public static void main(String[] args) {
03 int x = 1;
04 do {
05 //首先判断这个数是否是3的倍数，并且是否不是5的倍数
06 if ((3 * x) % 5 != 0) {
07 if ((3 * x) % 9 != 0) { //再判断是否不是9的倍数
08 System.out.println(3 ＊ x);
09 }
10 }
11 x++;
12 } while (((3 * x > 1) && (3 * x < 100))); //最后判断是否在100以内
13 }
14 }
【运行效果】
3 6 12 21 24 33 39 42 48 51 57 66 69 78 84 87 93 96
【代码说明】从上面的程序段输出结果可以看出，与使用while语句的输出结果是一样的，为什么会是一样的呢？下面来分析。
当“x=33”时，先不会检验“3*33=99”是否小于100，而是先执行大括号内的循环体。当检测到99是9的倍数时，条件是“false”，于是就会退出条件语句，继续执行“x”自加1表达式，于是“x”变成了34，由于“34*3=102”大于100，所以结束循环体。因此程序执行到“x=32”后就无输出了，最后输出的结果当然和while语句的输出一样。
其实在实际程序开发中，不经常使用do…while循环语句。因为这种语句是先执行循环体再检测条件，所以会有一些危险数据不经检测，就会被执行。建议使用while语句或者for循环语句来编写代码。
4.4 中断与继续语句
在实际编程中，可能会出现中断某个程序；或从一个程序点开始，继续执行程序的特殊情况。对于这些特殊情况，Java会使用中断与继续功能来解决。
4.4.1 中断控制语句
在Java程序开发中，使用关键字break来表示中断控制。中断控制语句用来强行退出程序的循环体部分或分支语句（如switch语句）。在switch分支语句中，已经使用过break语句，一旦执行该跳转语句，程序就退出switch语句。
【实例4-14】为了能熟悉中断控制语句，下面看一个简单的程序段，通过这个例子，可以看到中断控制语句在实际开发中的用处。
01 //通过system.out语句可以将数据打印出来
02 public class control11
03 {
04 public static void main(String[] args)
05 {
06 int i=1;
07 while(i<=10) //循环
08 {
09 System.out.println(i);
10 i++; //值自加
11 if(i>5)
12 {break;} //退出
13 }
14 }
15 }
【代码说明】第11行添加了一个条件语句，当变量i大于5时，使用break语句退出while循环体。
【运行效果】
1 2 3 4 5
【实例4-15】如果上述代码中，没有中断语句强行退出，则代码如下所示：
01 //如果没有中断语句，则会循环到最后
02 public class control12
03 {
04 public static void main(String[] args)
05 {
06 int i=1;
07 while(i<=10) //循环
08 {
09 System.out.println(i); //输出值
10 i++;
11 }
12 }
13 }
【代码说明】第7～11行是while循环体，这里没有使用中断语句，所以符合条件的变量i值全部输出。
【运行效果】
1 2 3 4 5 6 7 8 9 10
从上面两个实例的程序段运行结果可以看出：当使用了break语句后，程序执行到“x=6”时，根据条件判断“x>5”，执行中断语句，直接退出程序的循环体部分。
说明
由以上程序段可以总结出一个规律：中断语句一般会与条件语句结合使用，当满足条件语句中的条件时，就会执行中断语句。
【实例4-16】下面再看一个有关中断语句的例子。
01 //将system.out语句放置在中断语句之前，则会循环一次，再退出循环
02 public class control13
03 {
04 public static void main(String[] args)
05 {
06 for(int i=2;i<10;i++)
07 {
08 System.out.println(i); //输出语句
09 if(i%2==0)
10 {break;} //退出
11 }
12 System.out.println("退出来了"); //输出提示
13 }
14 }
【代码说明】第9～10行是条件语句和中断语句的集合，在符合条件的时候，退出for循环体。当“i”是偶数的时候，直接中断循环体。由于第8行的输出方法属于循环体中的方法，所以不会执行它。
【运行效果】
2 退出来了
【实例4-17】将输出方法的位置进行调整，再看下面的代码。
01 //将system.out语句的位置放置在中断语句之后，则直接退出循环
02 public class control14
03 {
04 public static void main(String[] args)
05 {
06 for(int i=2;i<10;i++) //for循环
07 {
08 if(i%2==0)
09 {break;} //退出
10 System.out.println(i); //输出值
11 }
12 System.out.println("退出来了"); //输出提示
13 }
14 }
【代码说明】与前面的程序段一样，代码会直接跳出循环体程序，第12行的输出方法在循环体外，所以得以执行。
【运行效果】
退出来了
通过上述几个实例，可以总结出中断语句的使用方法：一般和条件判断语句结合使用，中断语句是中断整个循环体。跳出循环体后，直接执行循环体以外的语句。
4.4.2 继续语句
在Java程序设计中，继续语句使用关键字continue表示。当执行continue语句时，程序从循环体的开始处执行，而不考虑循环体中已经执行了多少轮循环，在for循环语句中，执行到continue语句时，不再执行循环体中其他代码，而是直接跳转到增量表达式，再开始下一轮的for循环。在while和do…while语句中，运行到continue语句时则跳转到相应的条件表达式，再开始下一轮的循环。
【实例4-18】下面先看一个有关继续语句的实例。
01 //只在奇数时，才输出，偶数时，会退出本次循环
02 public class control15
03 {
04 public static void main(String[] args)
05 {
06 for(int i=1;i<10;i++) //for循环
07 {
08 if(i%2==0)
09 {continue;} //继续语句
10 System.out.println(i); //输出值
11 }
12 System.out.println("退出来了"); //输出提示
13 }
14 }
【代码说明】仔细分析以上的程序段，如果使用break语句，那么运行结果中只有一个“1”，而用了继续语句，则输出了10以内的奇数。在程序中，如果i是偶数，遇到继续语句，就终止“System.out.println(i)”这条语句，又跳到循环开始，重新循环。所以，只要遇到偶数就会终止程序，遇到奇数程序就会继续运行。
【运行效果】
1 3 5 7 9 退出来了
注意
一定要注意break和continue的区别，break是直接跳出循环，而continue只是中断当次循环。如果后面的条件满足要求，还会继续执行。
4.5 分支语句
在讲述条件判断语句时，曾经提到当判断条件过多时，可以使用分支语句来编写。之所以使用分支语句而不是if/else条件语句，是因为当需要判断的条件过多时，后者实现时会显得很烦琐，为了解决该问题，可以利用分支语句。
分支语句的基本结构是：
switch(整数因子)
{
case 整数值1：语句；break;
case 整数值2：语句；break;
case 整数值3：语句；break;
case 整数值4：语句；break;
case 整数值5：语句；break;
…
default:语句；
}
同样，先看看分支语句的流程图，如图4-9所示。
图4-9 分支语句流程图
如果仍然使用条件判断语句，整个程序段会显得层次过多，程序显得过于复杂，不易阅读。
【实例4-19】下面通过实际程序段，来了解条件判断语句和分支语句的区别。
01 public class control16
02 {
03 public static void main(String[] args)
04 {
05 int i=8; //定义变量i
06 if(i==1) //当变量i为1时
07 {System.out.println("是一月份");}
08 if(i==2) //当变量i为2时
09 {System.out.println("是二月份");}
10 if(i==3) //当变量i为3时
11 {System.out.println("是三月份");}
12 if(i==4) //当变量i为4时
13 {System.out.println("是四月份");}
14 if(i==5) //当变量i为5时
15 {System.out.println("是五月份");}
16 if(i==6) //当变量i为6时
17 {System.out.println("是六月份");}
18 if(i==7) //当变量i为7时
19 {System.out.println("是七月份");}
20 if(i==8) //当变量i为8时
21 {System.out.println("是八月份");}
22 if(i==9) //当变量i为9时
23 {System.out.println("是九月份");}
24 if(i==10) //当变量i为10时
25 {System.out.println("是十月份");}
26 if(i==11) //当变量i为11时
27 {System.out.println("是十一月份");}
28 if(i==12) //当变量i为12时
29 {System.out.println("是十二月份");}
30 }
31 }
【代码说明】第6～29行是12个if条件语句。这是判断月份，如果要判断的条件更多，是不是需要写更多的if语句呢？这说明判断条件非常多时，使用if语句显得层次有些混乱。
【运行效果】
是八月份
这个程序段看着不是很舒服，并且有点杂乱，下面再看看使用分支语句编写的程序段是什么样子。先来绘制一下流程图，如图4-10所示。
图4-10 输出一年月份程序流程图
【实例4-20】为了便于浏览，图4-10只绘制了1～6月份的流程。下面是这个程序的具体代码。
01 public class control17
02 {
03 public static void main(String[] args)
04 {
05 int i=8;
06 switch(i) //选择语句
07 {
08 case 1: System.out.println("是一月份");break; //退出语句
09 case 2: System.out.println("是二月份");break;
10 case 3: System.out.println("是三月份");break;
11 case 4: System.out.println("是四月份");break;
12 case 5: System.out.println("是五月份");break;
13 case 6: System.out.println("是六月份");break;
14 case 7: System.out.println("是七月份");break;
15 case 8: System.out.println("是八月份");break;
16 case 9: System.out.println("是九月份");break;
17 case 10: System.out.println("是十月份");break;
18 case 11: System.out.println("是十一月份");break;
19 case 12: System.out.println("是十二月份");break;
20 default: System.out.println("fault"); //默认语句
21 }
22 }
23 }
【代码说明】第6～21行是完整的分支语句，每个条件通过case来设置，条件执行完后，通过break语句来中断。第20行的default表示上述条件都不满足时，则执行它设置的输出。
【运行效果】
是八月份
说明
通过观察上面的程序段，会发现使用分支语句，整个程序更容易阅读。
4.6 返回语句
返回语句就是在执行程序的过程中，跳转到另一个程序。一般返回语句用在子程序或程序的函数方法中。返回语句使用关键字return来表示。下面通过一个简单的实例，了解返回语句的用法。
01 public void set(int a,int b)
02 {
03 i=a＊b
04 return; //返回语句
05 }
以上是一个小程序段，在程序中出现了return关键字，说明这个程序段结束了，返回到主运行程序中。还有一种情况，先看看下面的例子。
01 public int set()
02 {
03 return i=a*b //返回值
04 }
这种情况不但要返回到主运行程序，而且还要将“i=a*b”的值带回主运行程序中，将其值赋给主运行程序中的“i”。返回语句牵扯到不同方法之间的调用问题，我们会在讲解了类的方法之后再详细了解其应用环境。
4.7 常见疑难解答
4.7.1 普通循环是使用for语句还是while语句
根据情况不同而定，for循环语句主要针对有限循环而言，也就是说，当循环有上限的时候，一般使用for循环。while循环语句则针对那些无限循环的代码而言，当循环没有明确上限，上限只是根据程序中的条件而定。
4.7.2 一般的程序可否用分支语句来代替条件语句
这个要视具体情况而定，如果条件在三重之内，最好使用条件语句。如果超过了三重，最好使用分支语句。
4.8 小结
本章讲解的是Java程序设计中的流程控制，这是每种开发语言的基础，如果你学习过C语言，则本章内容并不复杂。流程控制主要通过条件判断、循环、中断、执行等一系列语句来完成，每个语句实现的功能不同，或者说技巧也不同。建议读者对本章中的每个例子都能亲自动手实现，如果出现了问题，还要多注意如何解决问题，这样就能知道更多的知识和技巧。
4.9 习题
一、填空题
1.循环语句总共有3种常见的形式：3.输入一个正整数，输出该数的阶乘。__________、__________和__________。
2.在Java程序开发中，使用关键字__________来表示中断控制。
3.__________就是在执行程序的过程中，跳转到另一个程序。
二、上机实践
1.通过程序实现求1～100之间不能被3整除的数之和。
【提示】关键代码如下：
for(int i=0;i<=100;i++){
if(i%3!=0){
sum=sum+i;
}
}
2.通过程序实现求整数1～100的累加值，但要求跳过所有个位为3的数。
【提示】关键代码如下：
for(int i=0;i<=100;i++){
// 判断个位数字是否为3
if(i%10==3){
continue;
}
sum=sum+i;
}
3.输入一个正整数，输出该数的阶乘。
【提示】整数n的阶乘公式为：n!=1×2×…×n。（n!表示n的阶乘）。
4.输入一个正整数n，判断该数是不是质数，如果是质数输出“n是一个质数”，否则输出“n不是质数”。
【提示】质数的含义：除了1和它本身不能被任何数整除。