流程控制
顺序结构
JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间都是按从上到下的顺序进行的，它是有若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
选择结构
Java 支持两种选择语句：if 语句和 switch 语句。
其中 if 语句使用布尔表达式或布尔值作为分支条件来进行分支控制，而 switch 语句则用于对多个整型值进行匹配，从而实现分支控制。这些语句允许你只有在程序运行时才能知道其状态的情况下，控制程序的执行过程。
选择结构（也叫分支结构）解决了顺序结构不能判断的缺点，可以根据一个条件判断执行哪些语句块。选择结构适合于带有逻辑或关系比较等条件判断的计算。例如，判断是否到下班时间，判断两个数的大小等。
if 选择结构
if 语句是使用最多的条件分支结构，它属于选择语句，也可以称为条件语句。
if 选择结构是根据条件判断之后再做处理的一种语法结构。默认情况下，if 语句控制着下方紧跟的一条语句的执行。不过，通过语句块，if 语句可以控制多个语句。
if 语句的最简语法格式如下，表示“如果满足某种条件，就进行某种处理”。
if(布尔表达式) {
//if 语句中的代码块。
}
//if 语句块后面的代码。
其中“条件表达式”和“语句块”是比较重要的两个地方。
- 条件表达式：条件表达式可以是任意一种逻辑表达式，最后返回的结果必须是一个布尔值。取值可以是一个单纯的布尔变量或常量，也可以是使用关系或布尔运算符的表达式。如果条件为真，那么执行语句块；如果条件为假，则语句块将被绕过而不被执行。
- 语句块：该语句块可以是一条语句也可以是多条语句。如果仅有一条语句，可省略条件语句中的大括号 {}。当从编程规范角度不要省略大括号，省略大括号会使程序的可读性变差。
if 条件语句的运行流程如图 1 所示。
编写一个 Java 程序，允许用户从键盘输入一个数字，再判断该数是否大于 100。使用 if 语句的实现代码如下：
public static void main(String[] args) {
System.out.println("请输入一个数字：");
Scanner input = new Scanner(System.in);
int num = input.nextInt(); // 接收键盘输入数据
// 判断用户输入的数据是否大于100
if (num > 100) {
System.out.println("输入的数字大于100");
}
// 判断用户输入的数据是否等于100
if (num == 100) {
System.out.println("输入的数字等于100");
}
// 判断用户输入的数据是否小于100
if (num < 100) {
System.out.println("输入的数字小于100");
}
}
运行该程序，分别使用键盘输入 99、100 和 105，结果如下所示：
请输入一个数字：
99
输入的数字小于100
请输入一个数字：
100
输入的数字等于100
请输入一个数字：
105
输入的数字大于100
if...else 选择结构
单 if 语句仅能在满足条件时使用，而无法执行任何其他操作（停止）。而结合 else 语句的 if 可以定义两个操作，此时的 if…else 语句表示“如果条件正确则执行一个操作，否则执行另一个操作”。
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
//if...else 语句块后面的代码。
在上述语法格式中，如果 if 关键字后面的表达式成立，那么就执行语句块 1，否则的话则执行语句块 2，其运行流程如图 2 所示。
if...else if...else选择结构
if 语句的主要功能是给程序提供一个分支。然而，有时候程序中仅仅多一个分支是远远不够的，甚至有时候程序的分支会很复杂，这就需要使用多分支的 if…else if 语句。
通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件才执行另一种处理……，这些条件都不满足则执行最后一种条件”。
if…else if 多分支语句的语法格式如下所示：
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
可以看出，else-if 结构实际上是 if-else 结构的多层嵌套。明显的特点就是在多个分支中只执行一个语句组，而其他分支都不执行，所以这种结构可以用于有多种判断结果的分支中。
在使用 if…else if 语句时，依次判断表达式的值，当某个分支的条件表达式的值为 true 时，则执行该分支对应的语句块，然后跳到整个 if 语句之外继续执行程序。如果所有的表达式均为 false，则执行语句块 n+1，然后继续执行后续程序，其运行流程如图所示。
嵌套if结构
if 语句的用法非常灵活，不仅可以单独使用，还可以在 if 语句里嵌套另一个 if 语句。同样，if…else 语句和 if…else if 语句中也可以嵌套另一个 if 结构的语句，以完成更深层次的判断。
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}
}
在上述格式中，应该注意每一条 else 与离它最近且没有其他 else 对应的 if 相搭配，其执行流程如图 所示。
switch case 结构
if…else 语句可以用来描述一个“二岔路口”，我们只能选择其中一条路来继续走，然而生活中经常会碰到“多岔路口”的情况。
switch 语句提供了 if 语句的一个变通形式，可以从多个语句块中选择其中的一个执行。
switch 语句是 Java 的多路分支语句。它提供了一种基于一个表达式的值来使程序执行不同部分的简单方法。因此，它提供了一个比一系列 if-else-if 语句更好的选择。
//你可以有任意数量的case语句
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
default : //可选
//语句
}
switch 语句的执行过程如下：表达式的值与每个 case 语句中的常量作比较。如果发现了一个与之相匹配的，则执行该 case 语句后的代码。如果没有一个 case 常量与表达式的值相匹配，则执行 default 语句。当然，default 语句是可选的。如果没有相匹配的 case 语句，也没有 default 语句，则什么也不执行。
if 语句和 switch 语句的区别
if 和 switch 语句都表示条件语句，可以从使用效率和实用性两方面加以区分。
1. 从使用效率上区分
从使用效率上区分，在对同一个变量的不同值作条件判断时，既可以使用 switch 语句，也可以使用 if 语句。使用 switch 语句的效率更高一些，尤其是判断的分支越多，越明显。
2. 从实用性上区分
从语句的实用性角度区分，switch 语句不如 if 条件语句，if 语句是应用最广泛和最实用的语句。
3. 何时使用 if 语句和 switch 语句
在程序开发的过程中，何时使用 if 语句和 switch 语句，需要根据实际情况而定，应尽量做到物尽其用。不能因为 switch 语句的效率高就一直使用，也不能因为 if 语句常用就不用 switch 语句。需要根据实际情况，具体问题具体分析，使用最适合的条件语句。
循环结构
循环是程序中的重要流程结构之一。循环语句能够使程序代码重复执行，适用于需要重复一段代码直到满足特定条件为止的情况。
所有流行的编程语言中都有循环语句。Java 中采用的循环语句与C语言中的循环语句相似，主要有 while、do-while 和 for。另外 Java 5 之后推出了 for-each 循环语句，for-each 循环是 for 循环的变形，它是专门为集合遍历而设计的。for-each 并不是一个关键字。
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环，否则循环将一直执行下去，形成死循环。
循环语句可能包含如下 4 个部分。
- 初始化语句（init statement）： 一条或多条语句，这些语句用于完成一些初始化工作，初始化语句在循环开始之前执行。
- 循环条件（test_expression）：这是一个 boolean 表达式，这个表达式能决定是否执行循环体。
- 循环体（body_statement）：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。如果这个代码块只有一行语句，则这个代码块的花括号是可以省略的。
- 迭代语句（iteration_statement）：这个部分在一次循环体执行结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束。
while 循环
while 语句是 Java 最基本的循环语句，是一种先判断的循环结构，可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。
while 循环语句的语法结构如下：
//**注意：我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。**
while( 布尔表达式 ) {
//循环内容
}
其中语句块中的代码可以是一条或者多条语句，而条件表达式是一个有效的 boolean 表达式，它决定了是否执行循环体。当条件表达式的值为 true 时，就执行大括号中的语句块。
执行完毕，再次检查表达式是否为 true，如果还为 true，则再次执行大括号中的代码，否则就跳出循环，执行 while 循环之后的代码。图 1 表示了 while 循环语句的执行流程。
do…while 循环
如果 while 循环一开始条件表达式就是假的，那么循环体就根本不被执行。然而，有时需要在开始时条件表达式即使是假的情况下，while 循环至少也要执行一次。换句话说，有时你需要在一次循环结束后再测试中止表达式，而不是在循环开始时。
幸运的是，Java就提供了这样的循环：do-while循环。do-while 循环语句也是 Java 中运用广泛的循环语句，它由循环条件和循环体组成，但它与 while 语句略有不同。do-while 循环语句的特点是先执行循环体，然后判断循环条件是否成立。
do-while 语句的语法格式如下：
//注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。
//如果布尔表达式的值为true，则语句块一直执行，直到布尔表达式的值为 false。
do {
//代码语句
}while(布尔表达式);
以上语句的执行过程是，首先执行一次循环操作，然后再判断 while 后面的条件表达式是否为 true，如果循环条件满足，循环继续执行，否则退出循环。while 语句后必须以分号表示循环结束，其运行流程如图 2 所示。
for循环
for 语句是应用最广泛、功能最强的一种循环语句。大部分情况下，for 循环可以代替 while 循环、do while 循环。
for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。
for 语句语法格式如下所示。
for(赋值语句; 条件语句; 迭代语句，通常使用 ++ 或 -- 运算符) {
//代码语句
}
for 关键字后面括号中的 3 个条件表达式必须用“;”隔开。for 循环中的这 3 部分以及大括号中使循环体必需的 4 个组成部分完美地结合在一起，简单明了。
for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。接下来进行下一次循环，直到条件表达式 2 的值为 false，才结束循环，其运行流程如图 1 所示。
值得指出的是，for 循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到 continue 语句结束本次循环，循环迭代语句也一样会得到执行。
for 循环和 while、do while 循环不一样：由于 while、do while 循环的循环迭代语句紧跟着循环体，因此如果循环体不能完全执行，如使用 continue 语句来结束本次循环，则循环迭代语句不会被执行。但 for 循环的循环迭代语句并没有与循环体放在一起，因此不管是否使用 continue 语句来结束本次循环，循环迭代语句一样会获得执行。
与前面循环类似的是，如果循环体只有一行语句，那么循环体的大括号可以省略。
demo for循环 九九乘法表，例子：
for (int i = 1; i <= 9; i++) {
for (int i1=1; i1 <= i; i1++) {
System.out.print(i1 + " * " + i + " = " + i*i1 + " ");
}
System.out.println();
}
结果
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
增强 for 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，能在不使用下标的情况下遍历数组。
foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。
foreach 循环语句的语法格式如下：
for(声明语句 : 表达式) {
//代码句子
}
for(type element: array){
System.out.println(element);
}
其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程如图 1 所示。
foreach 循环和普通循环不同的是，它无须循环条件，无须循环迭代语句，这些部分都由系统来完成，foreach 循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。
当使用 foreach 循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的实际意义，而且极容易引起错误
当使用 foreach 来迭代访问数组元素时，foreach 中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此，如果希望改变数组元素的值，则不能使用这种 foreach 循环。
使用 foreach 循环迭代数组元素时，并不能改变数组元素的值，因此不要对 foreach 的循环变量进行赋值。
return语句
return 关键字并不是专门用于结束循环的，return 语句用于终止函数的执行或退出类的方法，并把控制权返回该方法的调用者。如果这个方法带有返回类型，return 语句就必须返回这个类型的值；如果这个方法没有返回值，可以使用没有表达式的 return 语句。
return 语句的一般语法格式如下：
return 与方法相同类型的变量;
如果一个方法使用了 return 语句并且后面跟有该方法返回类型的值，那么调用此方法后，所得到的结果为该方法返回的值。
break 语句
某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 来完成这个功能。
break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能。
不带标签 break
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
使用 break 语句直接强行退出循环的示例如下：
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 定义变量存储小明的回答
String answer = "";
// 一圈100米，1000米为10圈，即为循环的次数
for (int i = 0; i < 10; i++) {
System.out.println("跑的是第" + (i + 1) + "圈");
System.out.println("还能坚持吗？"); // 获取小明的回答
answer = input.next();
// 判断小明的回答是否为y？如果不是，则放弃，跳出循环
if (!answer.equals("y")) {
System.out.println("放弃");
break;
}
// 循环之后的代码
System.out.println("加油！继续！");
}
}
该程序运行后的效果如下所示：
跑的是第1圈
还能坚持吗？
y
加油！继续！
跑的是第2圈
还能坚持吗？
y
加油！继续！
跑的是第3圈
还能坚持吗？
n
放弃
注意：一个循环中可以有一个以上的 break 语句，但是过多的 break 语句会破坏代码结构。switch 循环语句中的 break 仅影响 switch 语句，不会影响循环。
带标签 break
有时候，在嵌套很深的循环语句中会发生一些不可预料的事情。此时可能更加希望跳到嵌套的所有循环语句之外。通过添加一些额外的条件判断实现各层循环的检测很不方便。
幸运的是，Java 与 C++ 不同，Java 提供了一种带标签的 break 语句，用于跳出多重嵌套的循环语句。
break 语句可以实现 goto 的功能，并且 Java 定义了 break 语句的一种扩展形式来处理退出嵌套很深的循环这个问题。
通过使用扩展的 break 语句，可以终止执行一个或者几个任意代码块，这些代码块不必是一个循环或一个 switch 语句的一部分。同时这种扩展的 break 语句带有标签，可以明确指定从何处重新开始执行。
break 除了具有 goto 退出深层循环嵌套作用外，还保留了一些程序结构化的特性。
标签 break 语句的通用格式如下：
break label;
label 是标识代码块的标签。当执行这种形式的 break 语句时，控制权被传递出指定的代码块。被加标签的代码块必须包围 break 语句，但是它不需要直接包围 break 的块。也就是说，可以使用一个加标签的 break 语句来退出一系列的嵌套块，但是不能使用 break 语句将控制权传递到不包含 break 语句的代码块。
用标签（label）可以指定一个代码块，标签可以是任何合法有效的 Java 标识符，后跟一个冒号。加上标签的代码块可以作为 break 语句的对象，使程序在加标签的块的结尾继续执行。
带标签的break 语句的示例。
public class GotoDemo {
public static void main(String[] args) {
label: for (int i = 0; i < 10; i++) {
for (int j = 0; j < 8; j++) {
System.out.println(j);
if (j % 2 != 0) {
break label;
}
}
}
}
}
以上程序的执行结果为：
0
1
这里的 label 是标签的名称，可以为 Java 语言中任意合法的标识符。标签语句必须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。如果需要中断标签语句对应的循环，可以采用 break 后面跟标签名的方式。
注意：通常紧跟 break 之后的标签，必须在 break 所在循环的外层循环之前定义才有意义。
continue 关键字
有时强迫一个循环提早反复是有用的，也就是，你可能想要继续运行循环，但是要忽略这次重复剩余的循环体的语句，所以 Java 提供了 continue 语句。continue 语句是 break 语句的补充。
与 break 语句一样， 它将中断正常的控制流程。continue 语句将控制转移到最内层循环的首部。
continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。
continue 语句类似于 break 语句，但它只能出现在循环体中。它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。简单来讲，continue 是忽略循环语句的当次循环。
注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。
在循环体中使用 continue 语句有两种方式可以带有标签，也可以不带标签。语法格式如下：
不带标签 continue
下面看一个示例，代码如下：
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < numbers.length; i++) {
if (i == 3) {
continue;
}
System.out.println("Count is: " + i);
}
在上述程序代码中，当条件 i==3 的时候执行 continue 语句，continue 语句会终止本次循环，循环体中 continue 之后的语句将不再执行，接着进行下次循环，所以输出结果中没有 3。程序运行结果如下：
Count is: 0
Count is: 1
Count is: 2
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
带标签 continue label //label是标签名
带标签的 continue 语句示例代码如下：
public static void main(String[] args) {
label1: for (int x = 0; x < 5; x++) {
for (int y = 5; y > 0; y--) {
if (y == x) {
continue label1;
}
System.out.println(x+","+y);
}
}
System.out.println("Game Over!");
}
默认情况下，continue 只会跳出最近的内循环（代码第 3 行的 for 循环），如果要跳出代码第 2 行的外循环，可以为外循环添加一个标签 label1，然后在第 5 行的 continue 语句后面指定这个标签 label1，这样当条件满足执行 continue 语句时，程序就会跳转出外循环。
程序运行结果如下：
0,5
0,4
0,3
0,2
0,1
1,5
1,4
1,3
1,2
2,5
2,4
2,3
3,5
3,4
4,5
Game Over!
由于跳过了 x == y，因此下面的内容没有输出。
1,1
2,2
3,3
4,4
练习：输出杨辉三角形
利用过 Java 语言中的流程控制语句，如条件语句、循环语句和跳转语句等知识输出一个指定行数的杨辉三角形。
杨辉三角形由数字进行排列，可以把它看作是一个数字表，其基本特性是两侧数值均为 1，其他位置的数值是其左上方数值与右上角数值之和。打印杨辉三角形时需要使用到 for 循环语句。
打印杨辉三角形的实现思路是：
- 每一行前面都是空格，而每行空格的个数需要根据总行数来确定，这个可以通过找规律归纳出来。
- 关键是数值的实现，每一行的数值（除了第一列和最后一列）都是上一行两个数值之和，因此可以通过上一行来获取。
实现步骤如下：
(1) 创建名称为 Test28 的类，在该类中声明 num() 方法，在 num() 方法中传入两个参数，即 x 和 y。其中，x 表示行，y 表示列。num() 方法用于计算第 x 行第 y 列的数值。代码如下：
public static int num(int x, int y) {
if (y == 1 || y == x) {
return 1;
}
int c = num(x - 1, y - 1) + num(x - 1, y);
return c;
}
(2) 创建名称为 calculate 的方法，在该方法中传入一个 int 类型的参数，该参数表示打印杨辉三角形的行数。代码如下
public static void calculate(int row) {
for (int i = 1; i <= row; i++) {
for (int j = 1; j <= row - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
// 打印空格后面的字符, 从第1 列开始往后打印
System.out.print(num(i, j) + " ");
}
System.out.println();
}
}
(3) 在 main() 方法中添加代码，首先接收用户在控制台输入的打印行数，然后将行数作为参数传入到调用的 calculate() 方法中。代码如下：
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("打印杨辉三角形的行数：");
int row = scan.nextInt();
calculate(row);
}
(4) 运行代码进行测试，其运行结果如下所示：
打印杨辉三角形的行数：7
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
流程控制总结
任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转。
如果 main 方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。这意味着：如果没有流程控制，Java 方法里的语句是一个顺序执行流，从上向下依次执行每条语句。
不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。
- 分支结构用于实现根据条件来选择性地执行某段代码
- 循环结构则用于实现根据循环条件重复执行某段代码
Java 同样提供了这两种流程控制结构的语法，Java 提供了 if 和 switch 两种分支语句，并提供了 while、do while 和 for 三种循环语句。一般写循环语句时，分以下三步走：
- 定义初始值
- 设置判断条件
- 初始值变化
除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、数组的元素。
Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：
- break：表示跳出当前层循环
- continue：表示跳出本次循环，进入下一次循环
- return：跳出当前方法的循环
当在实现某个功能语句时，如果需要通过某一个条件去判断，则用选择结构。
当实现某个功能需要通过循环去实现，则用循环结构。
当然循环和选择是可以相互嵌套的。