Java 入门之8：Java分支结构，循环结构总结

目录

Java的中流程控制的分类：

顺序结构（sequential structure）图示：

分支结构（branch structure）（选择结构 （choice structure））

if单分支语法结构：​

if单分支流程图示：

if单分支结构总结：

if双分支语法结构：​

if双分支流程图示：

if双分支结构总结：

if多分支语法结构：​

if多分支流程图示：

if多分支结构总结：

switch分支语法结构：​

switch分支流程图示：​

switch分支结构总结：

循环结构（loop structure）

while循环标准语法结构：​

while循环流程图示：

while循环结构总结：

do-while循环标准语法结构：​

do-while循环流程图示：

do-while循环结构总结：

for循环标准语法结构：​

for循环流程图示：

for循环结构总结：

死循环（无限循环）结构（endless loop structure）：

while循环死循环语法结构：​

while循环死循环流程图示：​

do-while循环死循环语法结构：​

do-while循环死循环流程图示：​

for循环死循环语法结构：​ or ​

for循环死循环流程图示：​

分支结构和循环结构的使用场景及分类：

循环的分类：

for、while、do-while的应用场景：

循环中常用到的关键字：

break：

continue：

return：

除了return关键字之外的 其他退出程序的操作：

---

Java的中流程控制的分类：

1. 顺序结构：即这是Java执行代码是的默认结构，由上而下的依次执行每句代码。
2. 分支结构：有选择的执行某句代码，即如果怎么怎么样，否则怎么怎么样的逻辑结构。
3. 循环结构：有选择的循环执行某句代码，即满足条件怎么怎么样，再继续怎么怎么样，不满足又怎么怎么样的逻辑结构。

 

顺序结构（sequential structure）图示：

顺序结构：默认的执行结构。

---

分支结构（branch structure）（选择结构 （choice structure））

分支结构的作用：当出现一种或多种情况时，有选择的执行某一种情况的代码！

if单分支语法结构：

if单分支流程图示：

if单分支结构总结：

1. 由上流程图可见，if语句对表达式进行一次判断，如果判断为true，就执行代码语句块里面的代码，false则跳过该代码语句块不执行。
2. 如果if单分支的代码语句块中只有一句代码。则 {} 可以省略不写。

---

if双分支语法结构：

if双分支流程图示：

if双分支结构总结：

1. 由上流程图可见，当布尔表达式为true，执行if分支里面的代码，并结束分支，为false时，执行else分支里面的代码。并结束分支。
2. if(){}else{} 分支在一般场景下都可以使用三元运算代替。（除了如果调用的方法没有返回值或者只是满足某个条件执行某句代码就不能用三元运算代替，比如像if-else里面 有打印语句就不能用三元运算代替或者只是单纯的调用某个方法但这个方法没有返回值，或者只是满足某个条件执行某句代码就不能用三元运算代替！三元运算一定是要需要数据类型的变量来接收返回结果的！）

---

if多分支语法结构：

if多分支流程图示：

if多分支结构总结：

1. 由上流程图可见，当布尔表达式1为true时，执行代码语句块1；当布尔表达式2为true时，执行代码语句块2；当布尔表达式3为true时，执行代码语句块3；……，如果都所有的布尔表达式都不为true，则执行else分支的代码语句块。
2. 多分支结构里面的else：（细节）隐藏了一个条件，根它上面分支条件表达式的相反的功能。如图所示：
3. 多分支：有多个条件需要判断的时候使用，只要满足一个分支以后，满足的这个分支的后面的分支就不再继续判断执行了。效率高
4. 最后的那个else分支可以不写，那么只有当if(){}else if(){}……里面有条件满足才会执行里面的代码，如果都不满足，就没有分支代码语句块执行。所以else加还是不加就看实际需要了。else相当于一个 ”收拾烂摊子“ 的作用，哈哈哈。

---

switch分支语法结构：

[ ] 中的子分支语句块表示可有可无。

switch分支流程图示：

switch分支结构总结：

1. switch分支结构说明：
   1. switch语句会根据表达式or变量的值从相匹配的case标签处开始执行该所相匹配的case标签的代码语句块。一直执行到break语句处或者是switch语句的末尾，如果表达式的值与所有的case标签的值都不匹配，（如果存在default语句的情况），则执行default语句下面的代码语句块。根据表达式值的不同可以执行许多不同的操作，switch语句中case标签在JDK1.5之前必须是整数（long类型除外）或者枚举，不能是字符串，然而在JDK1.7之后允许使用字符串（String类型）作为匹配的值
   2. 注意事项：当表达式是等值判断的情况下！可以使用if单、双、多、分支结构或者switch结构，如果表达式是区间判断或者是布尔判断的话，就只能使用if单、双、多分支结构。(switch其实可以也可以完成，不过非常的麻烦！)
2. 由上图可见，switch后面的是一个()，()中表达式返回的结果是一个 等值 ，case标签的值就是和这个等值进行匹配的，如果匹配则执行相应的代码。这个等值的类型在JDK1.7之后可以是byte、short、char、int、String、枚举类型。（包括了 byte、short、char、int、String类型的静态常量）
   1. switch在 JDK1.5之前仅支持 基本数据整数类型 和 基本数据整数类型的包装类型，JDK1.5后 增加了 对枚举类的支持（其底层原理是给枚举的常量实例进行了内部的编号，进行编号和枚举常量实例的映射）。JDK1.7后增加了对 String 类型的支持，但不允许为null。（其底层原理就是通过String类型的hashCode码来实现的，String内部对hashCode进行了重写）、需要说明的是 基本数据整数类型的包装类型使用到Switch语句中 在编译的时候最终也会自动拆箱为基本数据类型。其本质仍然是只对基本数据整数类型的支持！
3. switch中break关键字就是为了防止代码的“case穿透”，即在switch中如果这个case匹配则执行它相应的代码，如果这个case后面没有加 break 关键字，则就会出现代码case穿透现象。即从匹配的这个case开始，会一直执行代码下去，遇到 break 才会结束switch分支！如果所有的case都没有break，则会从匹配的那个case开始会一直执行代码穿透到switch语句的末尾！所以每个case后面都应该加上 break 关键字。
4. case后面的值不能重复！否则编译不通过！case后面的值的类型应该和switch()里面的等值的类型是一样的，否则编译不通过！case 后面的值可以使用表达式和三元运算求出来，不过意义不大。且case后面的值不能使用变量代替！
5. switch里面(包括case标签)的三元运算只针对 ? 后面的备选值是 byte、short、char、int、String、枚举类型 的值的情况下可以使用！
6. default分支语句的作用类似于 if 分支中的else分支语句的作用是一样的，起到一个”收拾烂摊子“ 的作用，即所有的case 都不匹配的情况下，就会执行default分支语句下面的代码语句块。所有这个default分支语句可以不用写，前提是其中的case要有匹配的switch分支才有可执行的代码语句块！否则就没有执行的代码！这样switch分支的编写就毫无意义！
7. default分支语句原则上可以写switch分支中的任意位置，如果没有写到最后一个 case分支语句 的下面的话！后面就必须要加上break关键字，否则就会出现代码的”default穿透“现象，所以最后写到最后面！如果default分支语句是在最后一个 case分支语句 的下面的话，default分支语句的代码语句块下面的break关键字就可以省略不写！良好的编码习惯就是写上！
8. 如果编写的switch语句内部中没有default语句，那么最后一个case的break也可以省略不写！
9. 如果相邻分支的逻辑是一样的话，但需要匹配的的值的却是不一样的，那代码语句块就可以写在最后一个case 分支语句上，并加上break关键字，上面的case的 break可以省略不写！利用代码的“case穿透现象”优化重复的代码。场景比如： 匹配一年的哪 几个月 分别 是 春、夏、秋、冬。又比如： 匹配多少多少成绩 在 什么什么级别……
10. switch分支和if分支的区别：
    1. 如果表达式是等值判断的话，    那么 if、switch 分支都可以使用！
    2. 如果表达式是区间判断或者布尔判断的话，         那么 if 分支最好！
11. 如果switch有return关键字（返回语句or结束方法）break可以省略不写。unreachable statement（无法到达的声明）
12. switch分支的应用场景： 故就是等值判断匹配，且等值的情况相对较少的情况下；

---

循环结构（loop structure）

循环结构的作用：将部分代码重复执行，循环只是提高了程序员编写代码的效率，计算机底层在执行循环的时候依然是重复执行的！

循环结构的注意事项：条件判断语句中应该有使循环趋向于结束的表达式语句，否则会出现无限循环——即 “死” 循环

while循环标准语法结构：

while循环流程图示：

while循环结构总结：

1. while循环的条件初始化语句是在while循环语句的外面的，故这个条件初始化语句只会初始化一次！且这个条件初始化语句的变量属于“全局”变量，故离这个变量的最近的{}（作用域）中都可以使用！
2. 条件控制语句（或者叫迭代语句）的顺序可以在循环体的后面，也可以在循环体的前面，只是条件初始话值先运算和后运算的区别。一般都是写在循环体后面。
3. 条件控制语句一般条件初始化值都是 ++ ， -- 或者是其他的算术运算操作。条件初始化语句变量的 最后的值 即是 条件控制语句最后算术运算后 且 与条件判断语句 判断结果为false的那个值！ 比如：初始化语句是 int i = 1；判断语句是 i <= 5 ，控制语句是 i++; ， 那么最后 i的值就是 6;

---

do-while循环标准语法结构：

do-while循环流程图示：

do-while循环结构总结：

1. 由上图可见，do-while循环结构会先执行循环体代码和条件控制语句，然后才判断条件是否成立为true，若条件为true，则再次执行循环体和条件控制语句，如果为false则结束循环，所以就算条件最开始就不成立为false，do-while的循环体和条件控制语句由上而下也至少会执行一次！
2. do-while循环的条件初始化语句是在do-while循环语句的外面的，故这个条件初始化语句只会初始化一次！且这个条件初始化语句的变量属于“全局”变量，故离这个变量的最近的{}（作用域）中都可以使用！
3. 条件控制语句（或者叫迭代语句）的顺序可以在循环体的后面，也可以在循环体的前面，只是条件初始化值先运算和后运算的区别。一般都是写在循环体后面。
4. 条件控制语句一般都是条件初始化值 ++ ， -- 或者是其他的算术运算操作。条件初始化语句变量的 最后的值 即是 条件控制语句最后算术运算后 且 与条件判断语句 判断结果为false的那个值！ 比如：初始化语句是 int i = 1；判断语句是 i <= 5 ，控制语句是 i++; ， 那么最后 i的值就是 6;
5. do-while循环和while循环的区别：
   1. while：先判断，再执行！
   2. do-while：先执行，再判断， 所以循环体代码和条件控制语句至少会被执行一次。！do-while的while后面必须有分号结尾！
6. do-while的使用场景：
   1. 比如考试是否通过和补考的场景：
      1. while

         int score = 0;
                 int time = 0;
                 // 如果考试没有及格就要补考
                 while (score >= 90 && score <= 150) {
                     ++time;
                     if (time == 1) {
                         score += Math.random() * 151;
                         System.out.println("参加考试 while 第 " + time + " 次,分数 = " + score + "分。");
                         if (score >= 90 && score <= 150) {
                             System.out.println("分数 = " + score + "分 及格，不需要补考。");
                             break;
                         } else {
                             System.out.println("分数 = " + score + "分 不及格，需要补考第 " + time + " 次。" + "\r\n");
                         }
                     } else {
                         score = 0;
                         score += Math.random() * 151;
                         System.out.println("参加考试 while 第 " + time + " 次,分数 = " + score + "分。");
                         if (score >= 90 && score <= 150) {
                             System.out.println("分数 = " + score + "分 及格，第 ==>" + (time - 1) + " 次补考。");
                             break;
                         } else {
                             System.out.println("分数 = " + score + "分 不及格，需要补考第 ==> " + time + "次。" + "\r\n");
                         }
                     }
                 }

         test：no result!

      2. do-while；

         int grade = 0;
                 int count = 0;
                 do {
                     ++count;
                     if (count == 1) {
                         grade += Math.random() * 151;
                         System.out.println("参加考试do-while 第 " + count + " 次,分数 = " + grade + "分。");
                         if (grade >= 90 && grade <= 150) {
                             System.out.println("分数 = " + grade + "分 及格，不需要补考。");
                             break;
                         } else {
                             System.out.println("分数 = " + grade + "分 不及格，需要补考 " + count + " 次。" + "\r\n");
                         }
                     } else {
                         grade = 0;
                         grade += Math.random() * 151;
                         System.out.println("参加考试do-while 第 " + count + " 次,分数 = " + grade + "分。");
                         if (grade >= 90 && grade <= 150) {
                             System.out.println("分数 = " + grade + "分 及格，补考了 ==> " + (count - 1) + "次。");
                             break;
                         } else {
                             System.out.println("分数 = " + grade + "分 不及格，需要补考 ==> " + count + "次。" + "\r\n");
                         }
                     }
                     // 如果考试及格了就不用补考了。
                 } while (grade < 90 || grade > 150);

         test：

      3. 显然do-while循环相对于while循环来说更为使用得更为合理一些，虽然while循环在代码层面上来说也可以实现类似的需求！比如：其实这里举例的while循环它的条件判断改得跟do-while的一样，它们是一样的效果，不过按照场景来说，do-while相对来说更为合理一些，这只是为了举例而举例。（另外举例里面的循环语句中的 break 关键字可以选择性的去掉。加不加都可以的。）其实for，while，do-while在代码层面上来说，都是可以实现的！

---

for循环标准语法结构：

for循环流程图示：

for循环结构总结：

1. for循环结构语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构，由上图可见，for循环在第一次重复之前要进行初始化，即执行条件初始化语句；然后，对条件判断语句进行判断，如果结果为true，执行循环体的代码，否则，则结束循环，最后再每一次重复的时候，进制某种形式的 “步进”，即执行条件控制语句。（那个初始化的变量，也可以叫做迭代因子！）
2. for循环的变量一般都比较喜欢叫 i 。当然这个变量可以随意取的，这个变量的作用域只在for循环语句内部有效！变量的作用域范围就是离变量最近{}，所以在没有嵌套循环的情况下，多个for循环的变量是可以重复的！
3. 条件控制语句一般都是条件初始化值 ++ ， -- 或者是其他的算术运算操作。条件初始化语句变量的 最后的值 即是 条件控制语句最后算术运算后 且 与条件判断语句 判断结果为false的那个值！ 比如：初始化语句是 int i = 1；判断语句是 i <= 5 ，控制语句是 i++; ， 那么最后 i的值就是 6;
4. for的几种变形写法（在特殊的场景使用！）：
   1. ，如果使用这个for循环语法，那么这种形式的for循环的变量在for循环外部就可以使用！
   2. ，如果使用这个for循环语法，那么这种形式的for循环的变量在for循环外部也可以使用！
   3. ，这种语法的条件控制语句（或者叫迭代语句）的顺序可以在循环体的后面，也可以在循环体的前面，只是条件初始化值先运算和后运算的区别。一般都是写在循环体后面。
   4. ，如果使用这个for循环语法，那么这种形式的for循环的变量在for循环外部就可以使用！这种语法的条件控制语句（或者叫迭代语句）的顺序可以在循环体的后面，也可以在循环体的前面，只是条件初始化值先运算和后运算的区别。一般都是写在循环体后面。
   5. ，如果使用这个for循环语法，那么这种形式的for循环的变量在外部也可以使用！这种语法的条件控制语句（或者叫迭代语句）的顺序可以在循环体的后面，也可以在循环体的前面，只是条件初始化值先运算和后运算的区别。一般都是写在循环体后面。这种for循环语法跟while循环的语法差不多一样，所以可以直接使用while循环代替！

---

死循环（无限循环）结构（endless loop structure）：

while循环死循环语法结构：

while循环死循环流程图示：

do-while循环死循环语法结构：

do-while循环死循环流程图示：

for循环死循环语法结构： or

for循环死循环流程图示：

---

分支结构和循环结构的使用场景及分类：

1. if分支结构：适用于只有一个条件的时候。
2. if-else分支结构：适用于只有两个条件的时候。（除了如果调用的方法没有返回值或者只是满足某个条件执行某句代码就不能用三元运算代替，比如像if-else里面 有打印语句就不能用三元运算代替或者只是单纯的调用某个方法但这个方法没有返回值，或者只是满足某个条件执行某句代码就不能用三元运算代替！三元运算一定是要需要数据类型的变量来接收返回结果的！）
3. if-else if - else if - …… else分支结构：适用于两个条件以上（包括两个条件）的时候。
4. switch分支结构：适用于 等值 判断匹配，且等值的情况相对较少的情况下；(细节上面已说明！)

循环的分类：

1. 当型：while循环，for循环。
2. 直到型：do-while循环。
3. 常用的循环为for循环，常用的死循环为while的死循环！do-while一般在特殊场景下使用！。

for、while、do-while的应用场景：

1. for循环：从标准语法上可以看出，三个表达式会被依次执行到，执行顺序也是固定的，故for循环比较适用于循环次数固定的场景！ 在for循环内部，需要对条件初始化的变量进行条件控制即 （算术运算操作），算术运算方向要趋近于for循环结束的方向，否则就会发生死循环！（具体细节上面已经总结）
2. while循环：只有一个判断条件，结果为布尔值，如果为true时就执行循环，为false时就不执行，故while循环比较适用于不知道具体的循环次数，只知道循环达到某个条件时可以执行时使用，在while循环语句内部，需要对条件初始化的变量进行条件控制即 （算术运算操作），算术运算方向要趋近于while循环结束的方向，否则就会发生死循环！（具体细节上面已经总结）
3. do-while循环：和while循坏差不多，只是条件判断语句放到了循环的最后，所以就算条件判断语句一开始 就为 false 不满足，do-while循环的循环体代码，和条件控制都会由上而下 至少执行一遍！因此，do-while循环比较适用于不知道具体的循环次数，只知道满足某个条件时继续执行循环或结束执行循环！且循环肯定执行一次的场景！在do-while循环内部，需要对条件初始化的变量进行条件控制即 （算术运算操作），算术运算方向要趋近于do-while循环结束的方向，否则就会发生死循环！（具体细节上面已经总结）

for、while、do-while 它们的执行效率是一样的，底层都会一次一次重复的执行，只是因 算法逻辑的不同，可能就会出现些微差异，谁快谁慢没有绝对的标准！

以上所有的分支结构和循环结构和其他语句结构之间都是可以相互嵌套使用的！

---

循环中常用到的关键字：

break：

1. 作用：break在switch分支结构中的作用是结束/打断当前switch分支结构，在循环结构中是跳出/停止 离 break 最近的那个循环，

2. 常用场景就是跳出死循环，和跳出多重嵌套循环，和跳出switch分支结构（switch和循环嵌套），和在switch分支结构中防止代码 case 穿透！

3. 如果是嵌套循环的循环结构，当想跳出那一层循环的时候，则可以通过给 想跳出的那层循环取个flag（标号/标记），然后再break后面加上 flag 的名字即可，成功跳出循环的前提是标号的名字不能写错！
   1. 举例：，当 l 是15的时候就跳出循环。（break 跳出最外面层循坏的用法较多）
   2. 举例：多重嵌套循环也可以选择性的跳出。（使用场景很少！），其他结构相互嵌套是一样的！
   3. 不管是switch嵌套循环或者是循环嵌套switch，break是 只对 最近的语句起作用，不管是最近的是switch还是循环结构！
4. flag（标号）不是只能在循环语句的边上和switch语句的边上取，（在if语句和try语句的边上也可以取标号，从而使用break 跳出指定标号的代码。，不过这样用标号和break的场景特别的少，几乎没写这种代码，只能说语法上面允许！），一般都是在循环语句的边上和switch语句的边上用！。

---

continue：

1. 作用：如果是单层循环，则是跳过本次循环，继续下一次循环，如果是嵌套循环，则是跳过离 continue 最近的那个循环！且continue只能使用在循环语句中！
2. 注意事项：
   1. 如果循环体内部的continue关键字之后没有代码需要执行，那么加上continue是没有任何意义的！
   2. 在一般情况下（由上而下按顺序执行），在同continue一个作用域的continue的后面不能有其他代码语句，因为永远都不可能执行到，所以编译会报错！
   3. continue如果出现在嵌套循环中，当想跳过某层循环的本次循环！是可以像break一样配合 标号 来一起使用的！
   4. 如果continue出现在循环的末尾（即循环内部的最后一句代码！),那么continue就可以省略！
   5. continue对死循环无效。
   6. 一般使用continue的时候，所对应的场景一般都是比较有规律的，或者说是有目的性的！
3. 举例：
4. 举例：

    // 比如求1~2030年的闰年
           int fourYearOneLeap = 4;
           int hundredYearNoLeap = 100;
           int fourHundredYearAgainLeap = 400;
           int isLeapYear = 0;
           for (int year = 1; year <= 2030; year++) {
               if ((year % fourYearOneLeap == 0 && year % hundredYearNoLeap != 0) || year % fourHundredYearAgainLeap == 0) {
                   isLeapYear = year;
                   System.out.println("leap year is = " + year + " year");
                   continue;
               }
               if (1877 == isLeapYear) {
                   System.out.println("yes, 1877 is leap year!");
                   break;
               }else {
                   if (year == 2030){
                       System.out.println("no , 1877 isn't leap year!");
                   }
               }
           }

   test：

5. continue配合标号一起使用：

 

---

return：

1. 作用：
   1. 如果一个返回值为void的方法一旦执行到 return 关键字，则是结束当前的这个方法，比如在 main 方法中遇到了return关键字，它的作用就是退出当前的main方法，结束程序。其他的返回值为void 的方法，则是结束当前这个方法。回到调用该方法的位置，执行下面的代码。retur 结束方法和是不是循环结构无关，简单的来说，return 是属于 方法的关键字！所以 方法中的任何一种语句结构都有可以使用！
   2. 返回数据给方法的调用者。（前提是方法要是返回的数据类型！）返回值的数据类型必须与方法的签名中的声明的返回值类型一样或者比它还小。[可以使用强制类型转换来使用数据类型一致。前提是强转要通过！]
   3. return关键字的后面不能写代码，因为永远也不可能执行到。除了当return遇到finally关键字的时候，finally关键字里面的代码会执行之外！一般finally中的代码都是用来释放资源，比如IO操作，连接数据库等操作。其他写到return关键字后面的统统都不会执行，而且编译不通过！
2. 举例：

---

除了return关键字之外的 其他退出程序的操作：

System.exit(int status)这个方法是用来结束当前正在运行中的JVM。（强制停止程序）

1. 当System.exit(0)；表示正常退出程序，结束当前正在运行中的JVM，如果是在finally中！那么调用这个方法的语句的后面的代码都不会执行！
2. 当System.exit(非0);当status为非0时的其他整数（包括负数，一般都习惯用 1 或者 -1），表示非正常退出当前程序
3. System.exit()可以出现在任意的方法中！

正常退出与非正常退出的区别 ：

无论status是什么值，效果都是相同的，即：关闭当前运行中的JVM，

正常和非正常的用法，为了举例而举例！：

1. 比如在一个try-catch[-finally]语句结构中，如果程序是按照预期的执行，到最后如果需要停止程序。那么就可以使用System.exit(0);表示正常退出！
2. 而System.exit(1);一般都是放在catch语句中，当程序发生了错误，如果需要停止程序，那么就可以使用Systeml.exit(1)，这时status=非0且整数 则表示这个程序非正常退出！

---