知识框架
控制语句概述
在大部分编程语言当中都会存在控制语句，控制语句是一个程序的灵魂，我们只依靠“标识符、关键字、变量、运算符”等零散的知识点是无法进行流程控制的，无法实现一个具体的功能或业务，所以控制语句这一章节非常重要。现实生活中哪些业务需要使用控制语句呢？比如说“小孩身高如果高于 1.2 米，则乘坐交通工具就需要收费了，反之则免费”，再比如“A 账户向 B 账户转账 10000 元，首先需要判断 A账户的余额是否大于等于 10000 元，如果余额充足则可以转账，不足则无法转账”等等，这些业务当中都需要使用控制语句进行控制才能完成。什么是控制语句，官方的解释是这样的：控制语句即用来实现对程序流程的选择、循环、转向和返回等进行控制。Java 语言中共有 8 种控制语句，可以分为“选择语句”，“循环语句”，“转向语句”，“返回语句”四类。那么，这 8 种控制语句分别是什么呢？if 语句、switch 语句、for 循环、while 循环、do..while 循环、break 语句、continue 语句、return 语句。其中 if 和switch 语句属于选择语句，for、while、do..while 语句属于循环语句，break 和 continue 语句属于转向语句，return 属于返回语句。流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。 其中Java中的控制语句由三种基本流程语句组成，接下来让我们认真的学习每一个语句。
顺序语句：
- 程序顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
顺序结构执行流程图：
代码演示
/* 顺序结构 */ public class OrderDemo { public static void main(String[] args) { System.out.println("开始"); System.out.println("语句A"); System.out.println("语句B"); System.out.println("语句C"); System.out.println("结束"); } }
选择语句
选择语句又称为分支语句，它通过对给定的条件进行判断，从而决定执行两个或多个分支中的哪一支。因此，在编写选择语句之前，应该首先明确判断条件是什么，并确定当判断结果为“真”或“假”时应分别执行什么样的操作/算法。在 Java 语言中选择语句主要提供了两个，一个是 if 语句，另一个则是 switch 语句。
选择语句之if语句
if语句第一种格式： if
格式：
执行流程：
- ①首先计算关系表达式的值
- ②如果关系表达式的值为true就执行语句体
- ③如果关系表达式的值为false就不执行语句体
- ④继续执行后面的语句内容
if语句流程图
代码演示
/* if语句格式1 格式： if (关系表达式) { 语句体; } 执行流程： 1:首先计算关系表达式的值 2:如果关系表达式的值为true就执行语句体 3:如果关系表达式的值为false就不执行语句体 4:继续执行后面的语句内容 */ public class Demo { public static void main(String[] args) { //定义两个变量 int a = 10; int b = 20; //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b if (a == b) { System.out.println("a等于b"); } //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c int c = 10; if (a == c) { System.out.println("a等于c");//a等于c } System.out.println("结束");//结束 } }
if语句第二种格式： if...else
格式：
执行流程：
- ①首先计算关系表达式的值
- ②如果关系表达式的值为true就执行语句体1
- ③如果关系表达式的值为false就执行语句体2
- ④继续执行后面的语句内容
if....else语句的执行流程图
代码演示
import java.util.Scanner; /* if语句格式2 格式： if (关系表达式) { 语句体1; } else { 语句体2; } 执行流程： 1:首先计算关系表达式的值 2:如果关系表达式的值为true就执行语句体1 3:如果关系表达式的值为false就执行语句体2 4:继续执行后面的语句内容 需求： 任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。 */ public class Demo { public static void main(String[] args) { //为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据) Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数："); //获取从外界输入的数字 int number = sc.nextInt(); /* 判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构 判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0 根据判定情况，在控制台输出对应的内容 */ if (number % 2 == 0) { System.out.println(number + "是偶数"); } else { System.out.println(number + "是奇数"); } } }
f语句第三种格式： if...else if ...else
格式：
执行流程：
- ①首先计算关系表达式1的值
- ②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
- ③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
- ④…
- ⑤如果没有任何关系表达式为true，就执行语句体n+1。
if..else if...else执行流程图
代码演示
/* if语句格式3 格式： if (关系表达式1) { 语句体1; } else if (关系表达式2) { 语句体2; } … else { 语句体n+1; } 执行流程： 1:首先计算关系表达式1的值 2:如果值为true就执行语句体1；如果值为false就计算关系表达式2的值 3:如果值为true就执行语句体2；如果值为false就计算关系表达式3的值 4:… 5:如果没有任何关系表达式为true，就执行语句体n+1。 需求： 小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物， 假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。 奖励： 95~100 山地自行车一辆 90~94 游乐场玩一次 80~89 变形金刚玩具一个 80以下 胖揍一顿 */ import java.util.Scanner; public class Demo { public static void main(String[] args) { //小明的考试成绩未知，可以使用键盘录入的方式获取值 Scanner sc = new Scanner(System.in); System.out.println("请输入一个分数："); int score = sc.nextInt(); /* 由于奖励种类较多，属于多种判断，采用if...else...if格式实现 为每种判断设置对应的条件 为每种判断设置对应的奖励 */ //数据测试：正确数据，边界数据，错误数据 if(score>100 || score<0) { System.out.println("你输入的分数有误"); } else if(score>=95 && score<=100) { System.out.println("山地自行车一辆"); } else if(score>=90 && score<=94) { System.out.println("游乐场玩一次"); } else if(score>=80 && score<=89) { System.out.println("变形金刚玩具一个"); } else { System.out.println("胖揍一顿"); } } }
小结选择结构if语句
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
- 当多个条件是“包含”关系时，“小上大下 / 子上父
- 在某些简单的应用中，if语句是可以和三元运算符互换使用的。 三元运算符的执行效率比if语句要高，if语句的适用范围比三元运算符要多的多。
- 对于if语句来说，在任何情况下只能有1个分支执行，不可能存在2个或者更多个分支执行。if语句中只要有1个分支执行了，整个if语句就结束了。
- 凡是带有else分支的，一定可以保证会有一个分支执行。
if语句嵌套，代码举例
public class IfTest02 { public static void main(String[] args) { // 接收用户键盘输入 java.util.Scanner s = new java.util.Scanner(System.in); // 提示信息 System.out.print("请输入您的性别，输入1表示男，输入0表示女："); // 程序停下来等待用户的输入 int gender = s.nextInt(); // 提示信息 System.out.print("请输入当前的天气，1表示雨天，0表示晴天："); // 等待用户的输入 int weather = s.nextInt(); if (weather == 1) { //System.out.println("雨天"); if (gender == 1) { // 男 System.out.println("下雨了，小哥哥，出门的时候记得拿一把大黑伞哦！"); } else if (gender == 0) { // 女 System.out.println("下雨了，小姐姐，出门的时候记得带一把小花伞哦！"); } } else if (weather == 0) { //System.out.println("晴天"); if (gender == 1) { // 男 System.out.println("外面的天气不错，老铁们出去玩耍吧！"); } else if (gender == 0) { // 女 System.out.println("外面的天气晴朗，小姐姐要保护好皮肤哦，擦点防晒霜！"); } } } }
选择语句之switch语句
格式：
执行流程
- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
switch执行流程示意图
示例代码
/* 题目： 1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。 2、等级： 优：[90~100] 良：[80~90) 中：[70-80) 及格：[60~70) 不及格：[0-60) 3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。 必须使用switch语句来完成，你该怎么办？ */ public class SwitchTest02{ public static void main(String[] args){ // 提示用户输入学生成绩 java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入学生成绩："); double score = s.nextDouble(); if(score < 0 || score > 100){ System.out.println("您输入的学生成绩不合法，再见！"); return; // 这个代码的执行，会让main结束。 } int grade = (int)(score / 10); // 95.5/10结果9.55，强转为int结果是9 String str = "不及格"; switch(grade){ case 10: case 9: str = "优"; break; case 8: str = "良"; break; case 7: str = "中"; break; case 6: str = "及格"; } System.out.println("该学生的成绩等级为：" + str); } }
case的穿透性：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。代码举例
import java.util.Scanner; /* switch语句 格式： switch(表达式) { case 值1： 语句体1; break; case 值2： 语句体2; break; … default： 语句体n+1; [break;] } 格式说明： 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。 case：后面跟的是要和表达式进行比较的值。 break：表示中断，结束的意思，用来结束switch语句。 default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。 执行流程： 首先计算表达式的值。 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。 如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。 需求： 一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。 春：3、4、5 夏：6、7、8 秋：9、10、11 冬：1、2、12 */ public class Demo { public static void main(String[] args) { //键盘录入月份数据，使用变量接收 Scanner sc = new Scanner(System.in); System.out.println("请输入一个月份："); int month = sc.nextInt(); //case穿透 switch (month) { case 1: case 2: case 12: System.out.println("冬季"); break; case 3: case 4: case 5: System.out.println("春季"); break; case 6: case 7: case 8: System.out.println("夏季"); break; case 9: case 10: case 11: System.out.println("秋季"); break; default: System.out.println("你输入的月份有误"); } } }
switch语句有关规则
- switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；switch 虽然只能探测 int 类型，但是也可以将 byte,short,char 类型放到小括号当中，因为这些类型会自动转换成 int 类型（小容量向大容量转换称为自动类型转换）。
- case子句中的值必须是常量，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
- default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default
- case的穿透性：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
循环语句
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。
循环语句之一：for循环
格式：
执行流程：
执行顺序：①②③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化。初始化部分(init_statement)：在循环开始最初执行，而且只做唯一一次。初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
- ②负责判断是否满足循环条件，不满足则跳出循环。循环条件部分(test_exp) ：如果成立，则循环继续；如果不成立，则循环退出。循环条件部分必须是boolean类型表达式，当值为false时，退出循环
- ③具体执行的语句。循环体部分(body_statement)：重复要做的事情内容，若干行语句。
- ④循环后，循环条件所涉及变量的变化情况。迭代部分(alter_statement)：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。可以有多个变量更新，用逗号分隔。
for循环代码执行示意图
代码示例
/* for语句 格式： for(初始化语句;条件判断语句;条件控制语句) { 循环体语句; } 执行流程： 1:执行初始化语句 2:执行条件判断语句，看其结果是true还是false 如果是false，循环结束 如果是true，继续执行 3:执行循环体语句 4:执行条件控制语句 5:回到2继续 */ /* 统计 需求： 统计"水仙花数"一共有多少个，并在控制台输出个数 */ public class Demo { public static void main(String[] args) { //定义变量count，用于保存“水仙花数”的数量，初始值为0 int count = 0; //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束 for (int i = 100; i < 1000; i++) { //在计算之前获取三位数中每个位上的值 int ge = i % 10; int shi = i / 10 % 10; int bai = i / 10 / 10 % 10; //在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1 if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) { count++; } } //打印输出最终结果 System.out.println("水仙花共有：" + count + "个"); } }
for循环有各种变形，如下所示
/* 1、for循环的语法机制以及运行原理？ 语法机制： for(初始化表达式; 条件表达式; 更新表达式){ 循环体; // 循环体由java语句构成 } 注意： 第一：初始化表达式最先执行，并且在整个循环中只执行一次。 第二：条件表达式结果必须是一个布尔类型，也就是：true或false 执行原理： 先执行初始化表达式，并且初始化表达式只执行1次。 然后判断条件表达式的结果，如果条件表达式结果为true， 则执行循环体。 循环体结束之后，执行更新表达式。 更新完之后，再判断条件表达式的结果， 如果还是true，继续执行循环体。 直到更新表达式执行结束之后，再次判断条件时，条件为false， for循环终止。 更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新 某个变量的值，这样条件表达式的结果才有可能从true变成false，从而 终止for循环的执行，如果确实更新表达式，很有可能会导致死循环。 */ public class ForTest02{ public static void main(String[] args){ // 最常见的for循环 // 循环10次，输出0~9 /* 强调一下：对于以下的这个for循环，其中int i = 0; 最先执行，并且只执行一次，而且i变量属于for循环 的局部变量，for循环结束之后i的内存就释放了。 这个i变量只能在for循环中使用。 这个i变量属于for循环域。在main方法中没有办法直接使用。 */ for(int i = 0;i < 10;i++){ System.out.println("i = " + i); // 0 1 2 3....9 } //错误: 找不到符号 //System.out.println(i); // i变量的作用域就扩大了。 int i = 0; for(;i < 10;i++){ System.out.println("i --> " + i); // 0 1 2 3....9 } System.out.println("这里的i可以访问吗？i = " + i); // 这里的i可以访问吗？i = 10 // 变形 for(int k = 1; k <= 10; k++){ System.out.println("k --> " + k); // 1 2 ..... 9 10 } // 变形 for(int k = 1; k <= 10; ){ System.out.println("k --> " + k); // 1 2 ..... 9 10 k++; } // 变形 for(int k = 1; k <= 10; ){ k++; System.out.println("value --> " + k); // 2 3 4 5 6 7 8 9 10 11 } // for的其它形式 for(int a = 10; a > 0; a--){ System.out.println("a = " + a); // 10 9 8 7 6 5 4 3 2 1 } // 变形 for(int b = 0; b < 10; b += 2){ System.out.println("b = " + b); // 0 2 4 6 8 } } }
for循环嵌套
所谓嵌套循环，是指一个循环的循环体是另一个循环。将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环。请反复理解这句话：整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的。结论：外循环执行一次，内循环执行一圈
格式：
嵌套循环执行流程：
- 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
- 外循环一次，内循环多次。
/* 1、所有合法的“控制语句”都可以嵌套使用。 2、for循环嵌套一个for循环执行原理是什么？ 提示一下：大家不要因为for循环中嵌套了一个for循环，就感觉 这个程序比较特殊，实际上大家可以这样看待： for(){ //在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码. for(){} } */ public class ForTest02 { public static void main(String[] args) { // 单层for循环 for (int i = 0; i < 2; i++) { System.out.println("i = " + i); } for (int k = 0; k < 2; k++) { // 循环2次 for (int i = 0; i < 3; i++) { System.out.println("i ---> " + i); } } } }
循环语句之二：while 循环
格式：
执行流程
执行顺序：①②③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化。
- ②负责判断是否满足循环条件，不满足则跳出循环。
- ③具体执行的语句。
- ④循环后，循环变量的变化情况。
while循环代码执行示意图
代码举例
/* while循环： 1、while循环的语法机制以及执行原理 语法机制： while(布尔表达式){ 循环体; } 执行原理： 判断布尔表达式的结果，如果为true就执行循环体， 循环体结束之后，再次判断布尔表达式的结果，如果 还是true，继续执行循环体，直到布尔表达式结果 为false，while循环结束。 2、while循环有没有可能循环次数为0次？ 可能。 while循环的循环次数是：0~n次 */ public class Demo { public static void main(String[] args) { //定义一个计数器，初始值为0 int count = 0; //定义纸张厚度 double paper = 0.1; //定义珠穆朗玛峰的高度 int zf = 8844430; //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环 //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度 while (paper <= zf) { //循环的执行过程中每次纸张折叠，纸张的厚度要加倍 paper *= 2; //在循环中执行累加，对应折叠了多少次 count++; } //打印计数器的值 System.out.println("需要折叠：" + count + "次");//需要折叠：27次 } }
循环语句之三：do...while
格式：
执行流程
执行顺序：①③④>②③④>②③④…②不满足为止。
- ①负责完成循环变量初始化。
- ②负责判断是否满足循环条件，不满足则跳出循环。
- ③具体执行的语句
- ④循环后，循环变量的变化情况
do...while 代码执行示意图
示例：
/* do...while语句 基本格式： do { 循环体语句; }while(条件判断语句); 完整格式： 初始化语句; do { 循环体语句; 条件控制语句; }while(条件判断语句); 执行流程： 1:执行初始化语句 2:执行循环体语句 3:执行条件控制语句 4:执行条件判断语句，看其结果是true还是false 如果是false，循环结束 如果是true，继续执行 5:回到2继续 */ public class DoWhileDemo { public static void main(String[] args) { //需求：在控制台输出5次"HelloWorld" //for循环实现 for(int i=1; i<=5; i++) { System.out.println("HelloWorld"); } System.out.println("--------"); //do...while循环实现 int j = 1; do { System.out.println("HelloWorld"); j++; }while(j<=5); } }
三种循环的区别
- for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
- do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for循环和while的区别
- 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
- 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
- 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
死循环
死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
死循环（无限循环）的三种格式
- for(;;){}
- while(true){}
- do {} while(true);
代码示例
/* 永远停不下来的循环，叫做死循环。最常用的死循环的标准格式： while (true) { 循环体 } */ public class DemoDeadLoop { public static void main(String[] args) { while (true) { System.out.println("I Love Java!"); } // System.out.println("Hello"); 错误，永远执行不到的代码，不能编写 } }
程序流程控制关键字
关键字：break
- 用在switch语句当中，一旦执行，整个switch语句立刻结束。
- 用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。
代码示例：
/* break;语句： 1、break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。 另外：continue也是这样，他俩都是一个单词成为一条语句。 2、break 翻译为折断、弄断。 3、break;语句可以用在哪里呢？ 用在两个地方，其它位置不行 第一个位置：switch语句当中，用来终止switch语句的执行。 用在switch语句当中，防止case穿透现象，用来终止switch。 第二个位置：break;语句用在循环语句当中，用来终止循环的执行。 用在for当中 用在while当中 用在do....while..当中。 4、以下程序主要是以for循环为例学习break转向语句。 5、break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近 的那个循环语句。 6、怎么用break;语句终止指定的循环呢？ 第一步：你需要给循环起一个名字，例如： a: for(){ b:for(){ } } 第二步：终止：break a; */ public class BreakTest01{ public static void main(String[] args){ for(int i = 0; i < 10; i++){ if(i == 5){ // break;语句会让离它最近的循环终止结束掉。 break; // break;终止的不是if，不是针对if的，而是针对离它最近的循环。 } System.out.println("i = " + i); // 0 1 2 3 4 } // 这里的代码照常执行。break;的执行并不会影响这里。 System.out.println("Hello World!"); // 这个for循环两次 for(int k = 0; k < 2; k++){ // 外层for for(int i = 0; i < 10; i++){ // 内层for if(i == 5){ break; // 这个break;语句只能终止离它最近的for } System.out.println("i ===> " + i); } } System.out.println("------------------------------------------"); // 以下讲解的内容，以后开发很少用。不要紧张。 // 这种语法很少用，了解一下即可。 a:for(int k = 0; k < 2; k++){ b:for(int i = 0; i < 10; i++){ if(i == 5){ break a; // 终止指定的循环。 } System.out.println("i ===> " + i); } } System.out.println("呵呵"); } }
关键字：continue
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
代码示例：
/* continue;语句： continue翻译为：继续 continue语句的作用是： 终止当前"本次"循环，直接进入下一次循环继续执行。 for(){ if(){ // 当这个条件成立时，执行continue语句 continue; //当这个continue语句执行时，continue下面的代码不执行，直接进入下一次循环执行。 } // 以上的continue一旦执行，以下代码不执行，直接执行更新表达式。 code1 } 4、continue语句后面可以指定循环吗？ 可以的。 这里就不再讲了，自己测试以下。 a:for(;;更新表达式1){ b:for(;;更新表达式2){ if(){ continue a; } code1; } } */ public class ContinueTest01{ public static void main(String[] args){ for(int i = 0; i < 10; i++){ if(i == 5){ break; } System.out.println("i = " + i); } System.out.println("----------------------------"); for(int i = 0; i < 10; i++){ if(i == 5){ continue; } System.out.println("i = " + i); } } }
特殊流程控制语句说明
- break只能用于switch语句和循环语句中。
- continue 只能用于循环语句中。
- 二者功能类似，但continue是终止本次循环，break是终止本层循环。
- break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。