流程控制
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果 有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现 我们要完成的功能。其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
- 顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转。
- 分支结构：根据条件，选择性地执行某段代码，有if…else和switch-case两种分支语句。
- 循环结构：根据循环条件，重复性的执行某段代码。有while、do…while、for三种循环语句。
顺序结构
- 程序从上到下逐行地执行，中间没有任何判断和跳转。
顺序结构执行流程图
代码举例
// 顺序结构 public class Demo01Sequence { //顺序执行，根据编写的顺序，从上到下运行 public static void main(String[] args) { System.out.println("今天天气不错"); System.out.println("挺风和日丽的"); System.out.println("我们下午没课"); System.out.println("这的确挺爽的"); } }
选择结构
选择结构有if…else和switch-case两种分支语句。
接下来要学习的if条件语句分为三种语法格式，每一种格式都有它自身的特点，下面我们分别进行介绍。
if语句第一种格式： if
格式：
执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是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("结束");//结束 } }
扩展知识：
如何从键盘输入数据
/* 如何从键盘获取不同类型的变量：需要使用Scanner类 具体实现步骤： 1.导包：import java.util.Scanner; 2.Scanner的实例化:Scanner scan = new Scanner(System.in); 3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量 注意： 需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException 导致程序终止。 */ //1.导包：import java.util.Scanner; import java.util.Scanner; class ScannerTest{ public static void main(String[] args){ //2.Scanner的实例化 Scanner scan = new Scanner(System.in); //3.调用Scanner类的相关方法 System.out.println("请输入你的姓名："); //获取String类型数据 String name = scan.next(); System.out.println(name); System.out.println("请输入你的芳龄："); //获取int 类型数据 int age = scan.nextInt(); System.out.println(age); System.out.println("请输入你的体重："); //获取double 类型数据 double weight = scan.nextDouble(); System.out.println(weight); System.out.println("你是否相中我了呢？(true/false)"); //获取boolean 类型数据 boolean isLove = scan.nextBoolean(); System.out.println(isLove); //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串 System.out.println("请输入你的性别：(男/女)"); String gender = scan.next();//"男" char genderChar = gender.charAt(0);//获取索引为0位置上的字符 System.out.println(genderChar); } }
if语句第二种格式： if...else
格式：
执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是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 + "是奇数"); } } }
if语句第三种格式： if...else if ...else
格式：
执行流程
- 首先判断关系表达式1看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就继续判断关系表达式2看其结果是true还是false
- 如果是true就执行语句体2
- 如果是false就继续判断关系表达式…看其结果是true还是false
- …
- 如果没有任何关系表达式为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以下 胖揍一顿 说明： 1. else 结构是可选的。 2. 针对于条件表达式： > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。 > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。 > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。 */ 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语句和三元运算符的互换
在某些简单的应用中，if语句是可以和三元运算符互换使用的。 三元运算符的执行效率比if语句要高，if语句的适用范围比三元运算符要多的多。
代码演示
// 题目：使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值 public class DemoMax { public static void main(String[] args) { int a = 105; int b = 20; // 首先使用三元运算符 // int max = a > b ? a : b; // 使用今天的if语句 int max; if (a > b) { max = a; } else { max = b; } System.out.println("最大值：" + max);//最大值：105 } }
if语句嵌套，代码举例
/* 说明： 1. if-else结构是可以相互嵌套的。 2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。 */ 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执行流程示意图
示例代码
/* 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里面的语句体，然后程序结束掉。 2.说明： ① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。 当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构 末尾结束为止。 ② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构 ③ switch结构中的表达式，只能是如下的6种数据类型之一： byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增) ④ case 之后只能声明常量。不能声明范围。 ⑤ break关键字是可选的。 ⑥ default:相当于if-else结构中的else. default结构是可选的，而且位置是灵活的。 题目： 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; /* 需求： 一年有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结束。
小练习
/* 从键盘分别输入年、月、日，判断这一天是当年的第几天 注：判断一年是否是闰年的标准： 1）可以被4整除，但不可被100整除 或 2）可以被400整除 说明： 1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。 2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多）， 又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。 */ import java.util.Scanner; class SwitchCaseExer { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请输入year："); int year = scan.nextInt(); System.out.println("请输入month："); int month = scan.nextInt(); System.out.println("请输入day："); int day = scan.nextInt(); //定义一个变量来保存总天数 int sumDays = 0; switch (month) { case 12: sumDays += 30; case 11: sumDays += 31; case 10: sumDays += 30; case 9: sumDays += 31; case 8: sumDays += 31; case 7: sumDays += 30; case 6: sumDays += 31; case 5: sumDays += 30; case 4: sumDays += 31; case 3: //sumDays += 28; //判断year是否是闰年 if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { sumDays += 29; } else { sumDays += 28; } case 2: sumDays += 31; case 1: sumDays += day; } System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天"); } }
循环语句
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。
循环语句之一：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次 说明： 1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！ 2.我们写程序，要避免出现死循环。 3.for循环和while循环是可以相互转换的！ 区别：for循环和while循环的初始化条件部分的作用范围不同。 */ 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继续 说明： 1.do-while循环至少会执行一次循环体！ 2.开发中，使用for和while更多一些。较少使用do-while */ 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语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是 哪一层语句块
代码示例：
/* 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翻译为：继续 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之后不能有其他的语句，因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。