一、流程控制

1.1 概述

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

1.2 顺序结构

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

二、判断语句

2.1 单if语句

2.1.1 格式

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

2.1.2 执行流程

  • 首先判断关系表达式看其结果是 true还是false

    • 如果是 true 就执行【语句体】
    • 如果是 false 就不执行【语句体】
  1. public class Demo02If {
  2.     public static void main(String[] args) {
  3.         System.out.println("今天天气不错，正在压马路……突然发现一个快乐的地方：网吧");
  4.         int age = 19;
  5.         if (age >= 18) {
  6.             System.out.println("进入网吧，开始high！");
  7.             System.out.println("遇到了一群猪队友，开始骂街。");
  8.             System.out.println("感觉不爽，结账走人。");
  9.         }
  10.         System.out.println("回家吃饭");
  11.     }
  12. }

2.2 if…else语句

2.2.1 格式

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

2.2.2 执行流程

  • 首先判断关系表达式看其结果是 true还是false

    • 如果是 true 就执行【语句体1】
    • 如果是 false 就执行【语句体2】
  1. public class Demo03IfElse {
  2.     public static void main(String[] args) {
  3.         int num = 666;
  5.         if (num % 2 == 0) { // 如果除以2能够余数为0，说明是偶数
  6.             System.out.println("偶数");
  7.         } else {
  8.             System.out.println("奇数");
  9.         }
  10.     }
  11. }

2.3 if…else if…else语句

2.3.1格式

  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. }

2.3.2 执行过程

  • 首先判断关系表达式 1 看其结果是 true 还是 false

    • 如果是 true 就执行【语句体1】

    • 如果是 false 就继续判断关系表达式 2 看其结果是 true 还是 false

      • 如果是 true 就执行【语句体 2】

      • 如果是 false 就继续判断关系表达式…看其结果是 true 还是 false
        …

        • 如果没有任何关系表达式为 true，就执行【语句体 n+1】。
  1. // x和y的关系满足如下：
  2. // 如果x >= 3，那么y = 2x + 1;
  3. // 如果-1 < x < 3，那么y = 2x;
  4. // 如果x <= -1，那么y = 2x – 1;
  5. public class Demo04IfElseExt {
  6.     public static void main(String[] args) {
  7.         int x = -10;
  8.         int y;
  9.         if (x >= 3) {
  10.             y = 2 * x + 1;
  11.         } else if (-1 < x && x < 3) {
  12.             y = 2 * x;
  13.         } else {
  14.             y = 2 * x - 1;
  15.         }
  16.         System.out.println("结果是：" + y);
  17.     }
  18. }

2.4 练习

需求：指定考试成绩，判断学生等级，90-100 优秀，80-89 好，70-79 良=，60-69 及格，60 以下 不及格。

  1. public class Demo05IfElsePractise {
  2.     public static void main(String[] args) {
  3.         int score = 120;
  4.         if (score >= 90 && score <= 100) {
  5.             System.out.println("优秀");
  6.         } else if (score >= 80 && score < 90) {
  7.             System.out.println("好");
  8.         } else if (score >= 70 && score < 80) {
  9.             System.out.println("良");
  10.         } else if (score >= 60 && score < 70) {
  11.             System.out.println("及格");
  12.         } else if (score >= 0 && score < 60) {
  13.             System.out.println("不及格");
  14.         } else { // 单独处理边界之外的不合理情况
  15.             System.out.println("数据错误");
  16.         }
  17.     }
  18. }

2.5 if…else语句与三元运算符互换

  1. // 使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值
  2. public class Demo06Max {
  3.     public static void main(String[] args) {
  4.         int a = 105;
  5.         int b = 20;
  7.         // 首先使用三元运算符
  8.         // int max = a > b ? a : b;
  10.         // 使用今天的if语句
  11.         int max;
  12.         if (a > b) {
  13.             max = a;
  14.         } else {
  15.             max = b;
  16.         }
  18.         System.out.println("最大值：" + max);
  19.     }
  20. }

三、选择语句

3.1 switch语句

3.1.1 格式

  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. }

3.1.2 执行流程

  • 首先计算出表达式的值

    • case依次比较，一旦有对应的值，就会执行相应的语句体，如果没遇到break就会一直执行后面case里面的语句体，知道遇到break才会结束。
    • 最后，如果所有的 case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
  1. public class Demo07Switch {
  2.     public static void main(String[] args) {
  3.         int num = 10;
  5.         switch (num) {
  6.             case 1:
  7.                 System.out.println("星期一");
  8.                 break;
  9.             case 2:
  10.                 System.out.println("星期二");
  11.                 break;
  12.             case 3:
  13.                 System.out.println("星期三");
  14.                 break;
  15.             case 4:
  16.                 System.out.println("星期四");
  17.                 break;
  18.             case 5:
  19.                 System.out.println("星期五");
  20.                 break;
  21.             case 6:
  22.                 System.out.println("星期六");
  23.                 break;
  24.             case 7:
  25.                 System.out.println("星期日");
  26.                 break;
  27.             default:
  28.                 System.out.println("数据不合理");
  29.                 break; // 最后一个break语句可以省略，但是强烈推荐不要省略
  30.         }
  31.     }
  32. }

3.2 注意事项

  1. 1. case 后面的数值不可以重复。
  2. 3. case 后面可以是常量也可以是常量的运算（包括强制转换）。
  3. 4. switch 后面小括号当中只能是下列数据类型：
  4.     基本数据类型： byte / short / char / int
  5.     引用数据类型： String 、 enum 枚举 、 Character 、 Byte 、 Short 、 Integer
  6. 5. switch 如果是【基本数据类型】和 Character 、 Byte 、 Short ，那必须与 case 类型符合数据类型转换规则（即符合类型转换的类型和取值范围）。
  7. 6. 如果 switch 是 String 、 enum 、 Integer ，那 case 只能是对应的类型。
  8. 7. default 和 case 语句没有顺序，可以写在任一位置。
  9. 8. 如果 case 的后面不写 break ，将出现穿透现象，也就是不会再判断下一个 case 的值，直接向后运行，直到遇到 break ，或者整体 switch 结束。
  10. 9. 最后一个语句的 break ，可以不写，因为后面已经没有语句了，但不推荐。

四、循环语句

4.1 概述

循环结构的基本组成部分：

  1. 初始化语句：在循环开始最初执行，而且只做唯一一次。
  2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出。
  3. 循环体：重复要做的事情内容，若干行语句。
  4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

4.2 for循环语句

4.2.1 格式

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

4.2.2 执行流程

  • 执行顺序：①②③④ >②③④>②③④…直到②不满足为止。

    • ① 负责完成循环变量初始化
    • ② 负责判断是否满足循环条件，不满足则跳出循环
    • ③ 具体执行的语句
    • ④ 循环后，循环条件所涉及变量的变化情况
  1. public class Demo09For {
  2.    public static void main(String[] args) {
  3.        for (int i = 1; i <= 100; i++) {
  4.            System.out.println("我错啦！原谅我吧！" + i);
  5.        }
  6.        System.out.println("程序停止");
  7.    }
  8. }

4.3 while循环语句

4.3.1 格式

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

4.3.2 执行流程

  • 执行顺序：①②③④ >②③④>②③④…直到②不满足为止。

    • ① 负责完成循环变量初始化。
    • ② 负责判断是否满足循环条件，不满足则跳出循环。
    • ③ 具体执行的语句。
    • ④ 循环后，循环变量的变化情况。
  1. public class Demo10While {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i <= 10; i++) {
  4.             System.out.println("我错啦！" + i);
  5.         }
  6.         System.out.println("=================");
  8.         int i = 1; // 1. 初始化语句
  9.         while (i <= 10) { // 2. 条件判断
  10.             System.out.println("我错啦！" + i); // 3. 循环体
  11.             i++; // 4. 步进语句
  12.         }
  13.     }
  14. }

4.4 do…while循环语句

4.4.1 格式

  1. 初始化表达式①
  2.     do{
  3.     循环体③
  4.     步进表达式④
  5. }while(布尔表达式②);//注意这里有分号！！！

4.4.2 执行流程

  • 执行顺序：①③④ >②③④>②③④…②不满足为止。

    • ①负责完成循环变量初始化。
    • ②负责判断是否满足循环条件，不满足则跳出循环。
    • ③具体执行的语句
    • ④循环后，循环变量的变化情况
  1. public class Demo11DoWhile {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i <= 10; i++) {
  4.             System.out.println("原谅你啦！起来吧！地上怪凉！" + i);
  5.         }
  6.         System.out.println("===============");
  8.         int i = 1; // 1. 初始化语句
  9.         do {
  10.             System.out.println("原谅你啦！起来吧！地上怪凉！" + i); // 3. 循环体
  11.             i++; // 4. 步进语句
  12.         } while (i <= 10); // 2. 条件判断
  13.     }
  14. }

4.5 循环语句区别

  1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
  2. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。
  1. public class Demo13LoopDifference {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i < 0; i++) {
  4.             System.out.println("Hello");
  5.         }
  6.         // System.out.println(i); // 这一行是错误写法！因为变量i定义在for循环小括号内，只有for循环自己才能用。
  7.         System.out.println("================");
  9.         int i = 1;
  10.         do {
  11.             System.out.println("World");
  12.             i++;
  13.         } while (i < 0);
  14.         // 现在已经超出了do-while循环的范围，我们仍然可以使用变量i
  15.         System.out.println(i); // 2
  16.     }
  17. }

在已知循环次数的时候使用推荐使用 for，循环次数未知的时推荐使用while。

4.6 跳出语句

4.6.1 break

break除了可以用于switch语句，还可以用于循环语句中，表示跳出循环语句；除了这两种场景，其他地方都不能用break。

  1. public class Demo14Break {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i <= 10; i++) {
  4.             // 如果希望从第4次开始，后续全都不要了，就要打断循环
  5.             if (i == 4) { // 如果当前是第4次
  6.                 break; // 那么就打断整个循环
  7.             }
  8.             System.out.println("Hello" + i);
  9.         }
  10.     }
  11. }

4.6.2 continue

立刻跳过当前次循环剩余内容，马上开始下一次循环。

  1. public class Demo15Continue {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i <= 10; i++) {
  4.             if (i == 4) { // 如果当前是第4层
  5.                 continue; // 那么跳过当前次循环，马上开始下一次（第5层）
  6.             }
  7.             System.out.println(i + "层到了。");
  8.         }
  9.     }
  10. }

4.7 死循环

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

  • 在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

注意： 如果死循环后面没有其他语句，不会报错；如果死循环后面有其他语句时，编译会报错，因为后面的语句无法执行。

  1. public class Demo16DeadLoop {
  2.     public static void main(String[] args) {
  3.         while (true) {
  4.             System.out.println("I Love Java!");
  5.         }
  7.         // System.out.println("Hello");
  8.     }
  9. }

4.8 嵌套循环

是指循环里面还可以嵌套循环

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