第一章 流程控制

1.1 概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果 有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现 我们要完成的功能。

1.2 顺序结构

根据编写的顺序，从上到下运行

第二章 判断语句

2.1 判断语句1—if

格式

  1. if(关系表达式) {
  2.     语句体;
  3. }

执行流程

  • 首先判断关系表达式看其结果是true还是false
  • 如果是true就执行语句体
  • 如果是false就不执行语句体

3.0 流程控制语句 - 图1

例子

  1. public static void main(String[] args){
  2.     System.out.println("开始");
  3.     // 定义两个变量
  4.     int a = 10;
  5.     int b = 20;
  6.     //变量使用if判断
  7.     if (a == b){
  8.         System.out.println("a等于b");
  9.     }
  10.     int c = 10;
  11.     if(a == c){
  12.         System.out.println("a等于c");
  13.     }
  14.     System.out.println("结束");
  15. ｝

2.2 判断语句1—if……else

格式

  1. if(关系表达式) {
  2.     语句体1;
  3. }else {
  4.     语句体2;
  5. }

执行流程

  • 首先判断关系表达式看其结果是true还是false
  • 如果是true就执行语句体1
  • 如果是false就执行语句体2

3.0 流程控制语句 - 图2

例子

  1. public static void main(String[] args){
  2.     // 判断给定的数据是奇数还是偶数
  3.     // 定义变量
  4.     int a = 1;
  5.     if(a % 2 == 0) {
  6.         System.out.println("a是偶数");
  7.     } else{
  8.         System.out.println("a是奇数");
  9.     }
  10.     System.out.println("结束");
  11. }

2.3 判断语句1—if…else if…else

格式

  1. if (判断条件1) {
  2.     执行语句1;
  3. } else if (判断条件2) {
  4.     执行语句2;
  5. }
  6. ...
  7. }else if (判断条件n) {
  8.     执行语句n;
  9. } else {
  10.     执行语句n+1;
  11. }

执行流程

  • 首先判断关系表达式1看其结果是true还是false
  • 如果是true就执行语句体1
  • 如果是false就继续判断关系表达式2看其结果是true还是false
  • 如果是true就执行语句体2
  • 如果是false就继续判断关系表达式…看其结果是true还是false
  • …
  • 如果没有任何关系表达式为true，就执行语句体n+1

3.0 流程控制语句 - 图3

例子

  1. public static void main(String[] args) {
  2.     // x和y的关系满足如下：
  3.     // x>=3 y = 2x + 1;
  4.     //‐1<=x<3 y = 2x;
  5.     // x<=‐1 y = 2x – 1;
  6.     // 根据给定的x的值，计算出y的值并输出。
  7.     // 定义变量
  8.     int x = 5;
  9.     int y;
  10.     if (x>= 3) {
  11.         y = 2 * x + 1;
  12.     } else if (x >= ‐1 && x < 3) {
  13.         y = 2 * x;
  14.     } else {
  15.         y = 2 * x ‐ 1;
  16.     }
  17.     System.out.println("y的值是："+y);
  18. }

2.4 语句练习

  • 指定考试成绩，判断学生等级

    • 90-100 优秀
    • 80-89 好
    • 70-79 良
    • 60-69 及格
    • 60以下 不及格
  1. public static void main(String[] args) {
  2.     int score = 100;
  3.     if(score<0 || score>100){
  4.         System.out.println("你的成绩是错误的");
  5.     }else if(score>=90 && score<=100){
  6.         System.out.println("你的成绩属于优秀");
  7.     }else if(score>=80 && score<90){
  8.         System.out.println("你的成绩属于好");
  9.     }else if(score>=70 && score<80){
  10.         System.out.println("你的成绩属于良");
  11.     }else if(score>=60 && score<70){
  12.         System.out.println("你的成绩属于及格");
  13.     }else {
  14.         System.out.println("你的成绩属于不及格");
  15.     }
  16. }

2.5 if语句和三元运算符的转换

  1. public static void main(String[] args) {
  2.     int a = 10;
  3.     int b = 20;
  4.     //定义变量，保存a和b的较大值
  5.     int c;
  6.     if(a > b) {
  7.         c = a;
  8.     } else {
  9.         c = b;
  10.     }
  11.     //可以上述功能改写为三元运算符形式
  12.     c = a > b ? a:b;
  13. }

第三章 选择语句

3.1 选择语句—switch

格式

  1. switch(表达式) {
  2.     case 常量值1:
  3.         语句体1;
  4.         break;
  5.     case 常量值2:
  6.         语句体2;
  7.         break;
  8.     ...
  9.     default:
  10.         语句体n+1;
  11.         break;
  12. }

行流程

  • 首先计算出表达式的值
  • 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

3.0 流程控制语句 - 图4

3.2 case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运 行，直到遇到break，或者整体switch结束。

  1. public static void main(String[] args) {
  2.     int i = 5;
  3.     switch (i){
  4.         case 0:
  5.             System.out.println("执行case0");
  6.             break;
  7.         case 5:
  8.             System.out.println("执行case5");
  9.         case 10:
  10.             System.out.println("执行case10");
  11.         default:
  12.             System.out.println("执行default");
  13.     }
  14. }

上述程序中，执行case5后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接运行完整体switch。

由于case存在穿透性，因此初学者在编写switch语句时，必须要写上break。

注意事项

1，多个case后面的语句不可以重复

2，switch后面的小括号只能是以下数据类型

  1. 基本数据类型：byte/short/int/char
  3. 引用数据类型：    String字符串、enum枚举

3，switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略

  1. “匹配到哪一个case就从哪一个位置开始向下执行，直到遇到了break或者整体结束为止”

第四章

4.1循环语句概述

组成循环语句的四部分

1，初始化语句：在循环开始最初执行，而且只做唯一一次

2，条件判断语句：如果成立，循环继续；如果不成立，循环退出

3，循环体：重复要做的事情内容，若干行语句

4，步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次

4.2 循环语句1—for

格式

  1. for (初始化表达式①; 布尔表达式②; 步进表达式④) {
  2. 循环体③
  3. }

执行流程

  • 执行顺序：①②③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化
  • ②负责判断是否满足循环条件，不满足则跳出循环
  • ③具体执行的语句
  • ④循环后，循环条件所涉及变量的变化情况

3.0 流程控制语句 - 图5

例子

  1. public static void main(String[] args){
  2.     //for循环实现打印10次HelloWorld
  3.     for (int x = 0; x < 10; x++) {
  4.         System.out.println("HelloWorld"+x);
  5.     }
  6. }

4.3 循环语句2— while

格式

  1. 初始化表达式①
  2.     while(布尔表达式②){
  3.         循环体③
  4.         步进表达式④
  5.     }

执行流程

  • 执行顺序：①②③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化。
  • ②负责判断是否满足循环条件，不满足则跳出循环。
  • ③具体执行的语句。
  • ④循环后，循环变量的变化情况。

3.0 流程控制语句 - 图6

3.0 流程控制语句 - 图7

例子

  1. public static void main(String[] args) {
  2.     //while循环实现打印10次HelloWorld
  3.     //定义初始化变量
  4.     int i = 1;
  5.     //循环条件<=10
  6.     while(i<=10){
  7.         System.out.println("HelloWorld");
  8.         //步进
  9.         i++;
  10.     }
  11. }

4.4 循环语句3— do…while

格式

  1. 初始化表达式①
  2.     do{
  3.         循环体③
  4.         步进表达式④
  5.     }while(布尔表达式②);

执行流程

  • 执行顺序：①③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化。
  • ②负责判断是否满足循环条件，不满足则跳出循环。
  • ③具体执行的语句
  • ④循环后，循环变量的变化情况

3.0 流程控制语句 - 图8

例子

  1. public static void main(String[] args) {
  2.     //do...while循环实现打印10次HelloWorld
  3.     int x=1;
  4.     do {
  5.         System.out.println("HelloWorld");
  6.         x++;
  7.     }while(x<=10);
  8. }

特点

无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。这样的 循环具有一定的风险性

  1. public static void main(String[] args){
  2.     do{
  3.         System.out.println("无条件执行一次");
  4.     }while (false);
  5. }

4.5 输出1-100内偶数和

  1. public class Demo01HundredSum{
  2.     public static void main(String[] args){
  4.         // for
  5.         int sum = 0;
  6.         for (int i = 1; i <= 100; i++){
  7.             if (i % 2 == 0){
  8.                 // int sum = 0; // 注意作用域
  9.                 sum += i;
  10.             }
  11.         }
  12.         // System.out.println(i); // 超过作用域，变量不生效    
  13.         System.out.println("1-100之间的偶数和：" + sum);
  16.     /*    // while
  17.         int i = 0, sum = 0;
  18.         while (i <= 100){
  19.             if (i % 2 == 0){
  20.                 sum += i;
  21.             }
  22.             i++;
  23.         }
  24.         System.out.println("1-100之间的偶数和：" + sum);
  25.     */
  27.     /*    // do...while
  28.         int i = 0,sum = 0;
  29.         do{
  30.             if (i % 2 == 0){
  31.                 sum += i;
  32.             }
  33.             i++;
  34.         }while(i <=100);
  35.         System.out.println("1-100之间的偶数和：" + sum);
  36.     */
  37.     }
  38. }

4.6 循环语句区别

  • for 和 while 的小区别：

    • 如果判断条件一开始就为false，那么for循环和while循环将会执行0次，但是do-while循环至少会执行一次
    • 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消 失，能够提高内存的使用效率。
    • 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

4.7跳出循环语句

break

  • 使用场景：终止switch或者循环

    • 在选择结构switch语句中
    • 在循环语句中
    • 离开使用场景的存在是没有意义的
  1. public static void main(String[] args) {
  2.     for (int i = 1; i<=10; i++) {
  3.         //需求:打印完两次HelloWorld之后结束循环
  4.         if(i == 3){
  5.             break;
  6.         }
  7.         System.out.println("HelloWorld"+i);
  8.     }
  9. }

contiuce

使用场景：结束本次循环，继续下一次的循环

  1. public static void main(String[] args) {
  2.     for (int i = 1; i <= 10; i++) {
  3.         //需求:不打印第三次HelloWorld
  4.         if(i == 3){
  5.             continue;
  6.         }
  7.         System.out.println("HelloWorld"+i);
  8.     }
  9. }

第五章

5.1 死循环

也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}

注意：在没有跳出(break)语句的死循环后面写任何语句都会报错

5.2 嵌套循环

概念

是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总 共的循环次数=外循环次数*内循环次数

格式

  1. for (初始化表达式①; 循环条件②; 步进表达式⑦) {
  2.     for (初始化表达式③; 循环条件④; 步进表达式⑥) {
  3.         执行语句⑤;
  4.     }
  5. }

执行流程：

  • 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
  • 外循环一次，内循环多次。
  • 比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环。

例子

  1. public static void main(String[] args) {
  2.     for (int hour = 0; hour < 24; hour++) { // 外层控制小时
  3.         for (int minute = 0; minute < 60; minute++) { // 内层控制小时之内的分钟
  4.             System.out.println(hour + "点" + minute + “分”);
  5.         }
  6.     }
  7. }

练习：九九乘法表

  1. public class Nemo33_99CFB{
  2.     public static void main(String[] args){
  4.         for (int i = 1; i < 10; i++) {
  5.             for (int j = 1; j <= i; j++) {
  6.                 int num = i * j;
  7.                 System.out.print( j + "*" + i + "=" + num + "\t");
  8.             }
  9.             System.out.println();
  10.         }
  11.     }
  12. }