JavaSE_第三章【流程控制语句】

今日内容

  • if else判断语句
  • switch选择语句
  • for循环语句
  • while循环语句
  • do…while循环语句
  • break
  • continue

学习目标

  • [ ] 掌握键盘输入各种数据类型的值

  • [ ] 理解if语句的格式和执行流程

  • [ ] 理解if…else语句的格式和执行流程

  • [ ] 理解if…else if语句的格式和执行流程

  • [ ] 理解switch选择语句的格式和执行流程

  • [ ] 掌握switch选择语句接收的数据类型

  • [ ] 理解case的穿透性

  • [ ] 掌握break在switch中的使用

  • [ ] 掌握default在switch中的使用

  • [ ] 理解while语句的格式和执行流程

  • [ ] 了解do…while语句的格式和执行流程

  • [ ] 理解for语句的格式和执行流程

  • [ ] 了解跳出语句break，continue的意义

  • [ ] 理解死循环的执行流程

  • [ ] 理解循环嵌套的执行流程

第三章 流程控制

不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。其中分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。

3.1 顺序结构

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。

  1. public static void main(String[] args){
  2.     //顺序执行，根据编写的顺序，从上到下运行
  3.     System.out.println(1);
  4.     System.out.println(2);
  5.     System.out.println(3);
  6. }

3.2 输入语句

键盘输入代码的三个步骤：

1、准备Scanner类型的变量

2、提示输入xx

3、接收输入内容

示例代码：

  1. //1、准备Scanner类型的变量
  2. //Scanner是一个引用数据类型，它的全名称是java.util.Scanner
  3. //input就是一个引用数据类型的变量了，赋给它的值是一个对象
  4. java.util.Scanner input = new java.util.Scanner(System.in);//System.in默认代表键盘输入
  6. //2、提示输入xx
  7. System.out.print("请输入一个整数：");
  9. //3、接收输入内容
  10. int num = input.nextInt();
  12. //列出各种数据类型的输入
  13. int num = input.nextInt();
  14. long bigNum = input.nextLong();
  15. double d = input.nextDouble();
  16. boolean b = input.nextBoolean();
  17. String s = input.next();
  18. char c = input.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）

语法案例演示1：

从键盘输入个人信息

  1. class Day03_Test02_Input{
  2.     public static void main(String[] args){
  3.         //这里变量取什么名，下面就用什么.
  4.         //例如：这里取名input，下面就用input.
  5.         java.util.Scanner input = new java.util.Scanner(System.in);
  7.         System.out.print("请输入姓名：");
  8.         String name = input.next();
  10.         System.out.print("请输入年龄：");
  11.         int age = input.nextInt();
  13.         System.out.print("请输入性别：");
  14.         //input.next()得到字符串，不管你输入几个字符，
  15.         //.charAt(0)：从字符串中取出一个字符，(0)表示取第一个字符，(1)表示取第二个字符
  16.         //charAt(index)：也是一个方法，从第二个单词开始首字母大写，所以A是大写
  17.         char gender = input.next().charAt(0);
  19.         System.out.print("请输入体重：");
  20.         double weight = input.nextDouble();
  22.         System.out.print("请输入是否已婚(true/false)：");
  23.         boolean isMarry = input.nextBoolean();
  25.         System.out.println("姓名：" + name);
  26.         System.out.println("年龄：" + age);
  27.         System.out.println("性别：" + gender);
  28.         System.out.println("体重：" + weight);
  29.         System.out.println("婚否：" + (isMarry?"是":"否"));
  30.     }
  31. }

语法案例演示2：next()与nextLine()

  1. /*
  2. next()方法：
  3.     遇到空格等空白符，就认为输入结束
  4. nextLine()方法：
  5.     遇到回车换行，就认为输入结束
  7. 如果你在键盘输入过程中，遇到java.util.InputMismatchException，
  8. 说明你输入的数据类型与接收数据的变量的类型不匹配
  9. */
  10. class Day03_Test04_Input2{
  11.     public static void main(String[] args){
  12.         java.util.Scanner input = new java.util.Scanner(System.in);
  14.         System.out.print("请输入姓名：");
  15.         //String name = input.next();//张 三  只能接收张，后面的空格和三无法接收，被下面的输入接收
  16.         String name = input.nextLine();
  17.         System.out.println("name = " + name);
  19.         System.out.print("请输入年龄：");
  20.         int age = input.nextInt();    //23回车换行  这里只接收23，回车换行被下面的输入接收    
  21.         input.nextLine();//读取23后面的回车换行，但是这个不需要接收，只有下面一个输入是nextLine()情况下才需要这样，如果下面的输入是next()或者是nextInt(),nextDouble()等就不需要这么干
  22.         System.out.println("age = " + age);
  24.         System.out.print("请输入电话号码：");
  25.         String tel = input.nextLine();
  26.         System.out.println("tel = " + tel);
  27.     }
  28. }

3.3 分支结构：if语句第一种格式

  • if语句第一种格式： if
  1. if(条件表达式)｛
  2.       语句体;
  3. ｝

  • 执行流程

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

    • 如果是true就执行语句体

    • 如果是false就不执行语句体
      尚硅谷_高佳志_第3章 流程控制语句结构 - 图1

语法案例演示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月份的总天数。闰年2月份29天，平年28天。

闰年：
（1）能被4整除，不能被100整除
（2）能被400整除

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  4.         System.out.print("请输入年份：");
  5.         int year = input.nextInt();
  6.         int days = 28;
  8.         if(year%4==0 && year%100!=0 || year%400==0){
  9.             days++;
  10.         }
  11.         System.out.println(year + "年的2月份共" + days + "天");
  12.         input.close();
  13.     }
  14. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  4.         System.out.print("请输入年份：");
  5.         int year = input.nextInt();
  6.         int days = 28;
  8.         if(year%4==0 && year%100!=0 || year%400==0)
  9.             days++;//当语句块只有一句时，可以省略{}，但是建议还是保留比较靠谱
  11.         System.out.println(year + "年的2月份共" + days + "天");
  12.         input.close();
  13.     }
  14. }

3.4 分支结构：if语句第二种格式

  • if语句第二种格式： if…else
  1. if(关系表达式) { 
  2.       语句体1;
  3. }else {
  4.       语句体2;
  5. }

  • 执行流程

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

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

    • 如果是false就执行语句体2
      尚硅谷_高佳志_第3章 流程控制语句结构 - 图2

语法案例演示1：

  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：if语句和三元运算符的互换

在某些简单的应用中，if语句是可以和三元运算符互换使用的。

  1. public static void main(String[] args) {
  2.     int a = 10;
  3.     int b = 20;
  4.     //定义变量，保存a和b的较大值
  5.     int max;
  6.     if(a > b) {
  7.           max = a;
  8.     } else {
  9.           max = b;
  10.     }
  11.     //可以上述功能改写为三元运算符形式
  12.     max = a > b ? a : b;
  13. }
  1. public static void main(String[] args) {
  2.     int a = 10;
  3.     int b = 20;
  4.     //定义变量，保存a和b的较大值
  5.     int max;
  6.     if(a > b) 
  7.           max = a;//当语句块只有一个语句时，可以省略{}，但是不建议省略{}
  8.      else 
  9.           max = b;
  10. }

练习：求出最大值

从键盘输入三个数，求出最大值，用单分支if和双分支if..else来计算

  1. class Day03_Test08_MaxValueExer{
  2.     public static void main(String[] args){
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  5.         System.out.print("请输入第1个整数：");
  6.         int a = input.nextInt();
  8.         System.out.print("请输入第2个整数：");
  9.         int b = input.nextInt();
  11.         System.out.print("请输入第3个整数：");
  12.         int c = input.nextInt();
  14.         /*
  15.         int max;//存储三个数中的最大值
  16.         if(a > b){
  17.             max = a;
  18.         }else{
  19.             max = b;
  20.         }
  21.         if(c > max){
  22.             max = c;
  23.         }
  24.         */
  25.         int max = a>b ? a : b;
  26.         max = max>c ? max : c;
  27.         System.out.println(a+","+b+","+c+"中最大的是："+ max);
  28.     }
  29. }

3.5 分支结构：if语句第三种格式

  • if语句第三种格式： 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章 流程控制语句结构 - 图3

语法案例演示1：

计算如下函数：x和y的关系满足如下：
（1）x>=3； y = 2x + 1;
（2）-1<=x<3； y = 2x;
（3）x<-1； y = 2x – 1;
从键盘输入x的值，计算出y的值并输出。

  1. public static void main(String[] args) {
  2.     java.util.Scanner input = new java.util.Scanner(System.in);
  3.     System.out.print("请输入x的值：");
  4.     int x = input.nextInt();
  5.     int y;
  6.     if (x>= 3) {
  7.           y = 2 * x + 1;
  8.     } else if (x >= -1 && x < 3) {
  9.           y = 2 * x;
  10.     } else  {
  11.           y = 2 * x - 1;
  12.     }
  13.     System.out.println("y的值是："+y);
  14. }
  1. public static void main(String[] args) {
  2.     java.util.Scanner input = new java.util.Scanner(System.in);
  3.     System.out.print("请输入x的值：");
  4.     int x = input.nextInt();
  5.     int y;
  6.     if (x>= 3) {
  7.           y = 2 * x + 1;
  8.     } else if (x >= -1) {
  9.           y = 2 * x;
  10.     } else  {
  11.           y = 2 * x - 1;
  12.     }
  13.     System.out.println("y的值是："+y);
  14. }

尚硅谷_高佳志_第3章 流程控制语句结构 - 图4

尚硅谷_高佳志_第3章 流程控制语句结构 - 图5

语法案例演示2：

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

    • 90-100 优秀
    • 80-89 好
    • 70-79 良
    • 60-69 及格
    • 60以下 不及格
  1. public static void main(String[] args) {    
  2.     int score = 89；
  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. }

尚硅谷_高佳志_第3章 流程控制语句结构 - 图6

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

尚硅谷_高佳志_第3章 流程控制语句结构 - 图7

3.6 分支结构：if..else嵌套

在if的语句块中，或者是在else语句块中，
又包含了另外一个条件判断（可以是单分支、双分支、多分支）

执行的特点：
（1）如果是嵌套在if语句块中的
只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的
只有当外部的if条件不满足，进入else后，才会去判断内部的条件

语法案例演示1：

  1.     public static void main(String[] args) {    
  2.         int score = 89;
  3.         if(score<0 || score>100){
  4.               System.out.println("你的成绩是错误的");
  5.         }else{
  6.             if(score>=90){
  7.                   System.out.println("你的成绩属于优秀");
  8.             }else if(score>=80){
  9.                   System.out.println("你的成绩属于好");
  10.             }else if(score>=70){
  11.                   System.out.println("你的成绩属于良");
  12.             }else if(score>=60){
  13.                   System.out.println("你的成绩属于及格");
  14.             }else {
  15.                   System.out.println("你的成绩属于不及格");
  16.             }    
  17.         }
  18.     }
  1.     //省略{}的情况，else中嵌套了一个完整的多分支结构，也算是一个语句，称为复合语句，所以也可以省略{}
  2.     public static void main(String[] args) {    
  3.         int score = 89;
  4.         if(score<0 || score>100)
  5.               System.out.println("你的成绩是错误的");
  6.         else
  7.             if(score>=90){
  8.                   System.out.println("你的成绩属于优秀");
  9.             }else if(score>=80){
  10.                   System.out.println("你的成绩属于好");
  11.             }else if(score>=70){
  12.                   System.out.println("你的成绩属于良");
  13.             }else if(score>=60){
  14.                   System.out.println("你的成绩属于及格");
  15.             }else {
  16.                   System.out.println("你的成绩属于不及格");
  17.             }
  18.     }

语法案例演示2：

从键盘输入一个年份，和月份，输出该年份该月的总天数

要求：年份为正数，月份1-12

  1.     public static void main(String[] args){
  2.         //从键盘输入一个年份，和月份
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  5.         System.out.print("年份：");
  6.         int year = input.nextInt();
  8.         System.out.print("月份：");
  9.         int month = input.nextInt();
  11.         if(year>0){
  12.             if(month>=1 && month<=12){
  13.                 //合法的情况
  14.                 int days;
  15.                 if(month==2){
  16.                     if(year%4==0 && year%100!=0 || year%400==0){
  17.                         days = 29;
  18.                     }else{
  19.                         days = 28;
  20.                     }
  21.                 }else if(month==4 || month==6  || month==9 || month==11){
  22.                     days = 30;
  23.                 }else{
  24.                     days = 31;
  25.                 }
  26.                 System.out.println(year+"年" + month + "月有" + days +"天");
  27.             }else{
  28.                 System.out.println("月份输入不合法");
  29.             }
  30.         }else{
  31.             System.out.println("年份输入不合法");
  32.         }
  33.     }

3.7 分支结构：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.      】
  13. }

执行过程：

（1）入口

①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；

②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里

（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿

（3）出口

①自然出口：遇到了switch的结束

②中断出口：遇到了break等

注意：

（1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）

（2）case后面必须是常量值，而且不能重复

语法案例演示1：

  1. public class SwitchDemo01 {
  2.     public static void main(String[] args) {
  3.         //定义指定的星期
  4.         int weekday = 5;
  6.         //switch语句实现选择
  7.         switch(weekday) {
  8.             case 1:
  9.                 System.out.println("星期一");
  10.                 break;
  11.             case 2:
  12.                 System.out.println("星期二");
  13.                 break;
  14.             case 3:
  15.                 System.out.println("星期三");
  16.                 break;
  17.             case 4:
  18.                 System.out.println("星期四");
  19.                 break;
  20.             case 5:
  21.                 System.out.println("星期五");
  22.                 break;
  23.             case 6:
  24.                 System.out.println("星期六");
  25.                 break;
  26.             case 7:
  27.                 System.out.println("星期日");
  28.                 break;
  29.             default:
  30.                 System.out.println("你的数字有误");
  31.                 break;
  32.         }
  33.     }
  34. }

语法案例演示2：case的穿透性

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

练习：根据指定的月份输出对应季节（if语句）

  1. /*
  2.  * 需求：定义一个月份，输出该月份对应的季节。
  3.  *         一年有四季
  4.  *         3,4,5    春季
  5.  *         6,7,8    夏季
  6.  *         9,10,11    秋季
  7.  *         12,1,2    冬季
  8.  * 
  9.  * 分析：
  10.  *         A:指定一个月份
  11.  *         B:判断该月份是几月,根据月份输出对应的季节
  12.  *             if
  13.  *             switch
  14.  */
  15. public class SwitchTest01 {
  16.     public static void main(String[] args) {
  17.         //指定一个月份
  18.         int month = 5;
  20.         /*
  21.         if (month == 1) {
  22.             System.out.println("冬季");
  23.         } else if (month == 2) {
  24.             System.out.println("冬季");
  25.         } else if (month == 3) {
  26.             System.out.println("春季");
  27.         } else if (month == 4) {
  28.             System.out.println("春季");
  29.         } else if (month == 5) {
  30.             System.out.println("春季");
  31.         } else if (month == 6) {
  32.             System.out.println("夏季");
  33.         } else if (month == 7) {
  34.             System.out.println("夏季");
  35.         } else if (month == 8) {
  36.             System.out.println("夏季");
  37.         } else if (month == 9) {
  38.             System.out.println("秋季");
  39.         } else if (month == 10) {
  40.             System.out.println("秋季");
  41.         } else if (month == 11) {
  42.             System.out.println("秋季");
  43.         } else if (mouth == 12) {
  44.             System.out.println("冬季");
  45.         } else {
  46.             System.out.println("你输入的月份有误");
  47.         }
  48.         */
  50.         // 改进版
  51.         if ((month == 1) || (month == 2) || (month == 12)) {
  52.             System.out.println("冬季");
  53.         } else if ((month == 3) || (month == 4) || (month == 5)) {
  54.             System.out.println("春季");
  55.         } else if ((month == 6) || (month == 7) || (month == 8)) {
  56.             System.out.println("夏季");
  57.         } else if ((month == 9) || (month == 10) || (month == 11)) {
  58.             System.out.println("秋季");
  59.         } else {
  60.             System.out.println("你输入的月份有误");
  61.         }
  62.     }
  63. }

练习：根据指定的月份输出对应季节（switch语句）

  1. /*
  2.  * 需求：指定一个月份，输出该月份对应的季节。
  3.  *         一年有四季
  4.  *         3,4,5    春季
  5.  *         6,7,8    夏季
  6.  *         9,10,11    秋季
  7.  *         12,1,2    冬季
  8.  * 
  9.  * 分析：
  10.  *         A:指定一个月份
  11.  *         B:判断该月份是几月,根据月份输出对应的季节
  12.  *             if
  13.  *             switch
  14.  */
  15. public class SwitchTest02 {
  16.     public static void main(String[] args) {
  17.         //指定一个月份
  18.         int month = 5;
  20.         /*
  21.         switch(month) {
  22.             case 1:
  23.                 System.out.println("冬季");
  24.                 break;
  25.             case 2:
  26.                 System.out.println("冬季");
  27.                 break;
  28.             case 3:
  29.                 System.out.println("春季");
  30.                 break;
  31.             case 4:
  32.                 System.out.println("春季");
  33.                 break;
  34.             case 5:
  35.                 System.out.println("春季");
  36.                 break;
  37.             case 6:
  38.                 System.out.println("夏季");
  39.                 break;
  40.             case 7:
  41.                 System.out.println("夏季");
  42.                 break;
  43.             case 8:
  44.                 System.out.println("夏季");
  45.                 break;
  46.             case 9:
  47.                 System.out.println("秋季");
  48.                 break;
  49.             case 10:
  50.                 System.out.println("秋季");
  51.                 break;
  52.             case 11:
  53.                 System.out.println("秋季");
  54.                 break;
  55.             case 12:
  56.                 System.out.println("冬季");
  57.                 break;
  58.             default:
  59.                 System.out.println("你输入的月份有误");
  60.                 break;
  61.         }
  62.         */
  64.         // 改进版 
  65.         switch(month) {
  66.             case 1:
  67.             case 2:
  68.             case 12:
  69.                 System.out.println("冬季");
  70.                 break;
  71.             case 3:
  72.             case 4:
  73.             case 5:
  74.                 System.out.println("春季");
  75.                 break;
  76.             case 6:
  77.             case 7:
  78.             case 8:
  79.                 System.out.println("夏季");
  80.                 break;
  81.             case 9:
  82.             case 10:
  83.             case 11:
  84.                 System.out.println("秋季");
  85.                 break;
  86.             default:
  87.                 System.out.println("你输入的月份有误");
  88.                 break;
  89.         }
  90.     }
  91. }

常见错误实现1：

  1.         switch(month){
  2.             case 3|4|5://3|4|5 用了位运算符，11 | 100 | 101结果是 111是7
  3.                 System.out.println("春季");
  4.                 break;
  5.             case 6|7|8://6|7|8用了位运算符，110 | 111 | 1000结果是1111是15
  6.                 System.out.println("夏季");
  7.                 break;
  8.             case 9|10|11://9|10|11用了位运算符，1001 | 1010 | 1011结果是1011是11
  9.                 System.out.println("秋季");
  10.                 break;
  11.             case 12|1|2://12|1|2 用了位运算符，1100 | 1 | 10 结果是1111，是15
  12.                 System.out.println("冬季");
  13.                 break;
  14.             default:
  15.                 System.out.println("输入有误");
  16.         }

常见错误实现2：

  1.         //编译不通过
  2.         switch(month){
  3.             case 3,4,5:
  4.                 System.out.println("春季");
  5.                 break;
  6.             case 6,7,8:
  7.                 System.out.println("夏季");
  8.                 break;
  9.             case 9,10,11:
  10.                 System.out.println("秋季");
  11.                 break;
  12.             case 12,1,2:
  13.                 System.out.println("冬季");
  14.                 break;
  15.             default:
  16.                 System.out.println("输入有误");
  17.         }

Switch 表达式也是作为预览语言功能的第一个语言改动被引入Java12 中，开始支持如下写法：

  1.         switch(month) {
  2.             case 3,4,5 -> System.out.println("春季");
  3.             case 6,7,8 -> System.out.println("夏季");
  4.             case 9,10,11 -> System.out.println("秋季");
  5.             case 12,1,2 -> System.out.println("冬季");
  6.             default->System.out.println("月份输入有误！");
  7.         };

3.8 循环结构：while循环

需求：打印10次的HelloWorld

  1. public class ForDemo01 {
  2.     public static void main(String[] args) {
  3.         //控制台输出10次HelloWorld，不使用循环
  4.         System.out.println("HelloWorld");
  5.         System.out.println("HelloWorld");
  6.         System.out.println("HelloWorld");
  7.         System.out.println("HelloWorld");
  8.         System.out.println("HelloWorld");
  9.         System.out.println("HelloWorld");
  10.         System.out.println("HelloWorld");
  11.         System.out.println("HelloWorld");
  12.         System.out.println("HelloWorld");
  13.         System.out.println("HelloWorld");
  14.         System.out.println("-------------------------");
  16.         //用循环改进，循环10次
  17.         //定义变量从10开始，循环条件为<=10
  18.         int i = 1;
  19.         while(i <= 10){
  20.             System.out.println("HelloWorld");
  21.             i++;
  22.         }
  23.     }
  24. }

1、while循环语句标准格式：

  1. while (循环条件语句①) {
  2.     循环体语句②；
  3. }
  4. while(true){
  5.      循环体语句;//如果此时循环体中没有跳出循环的语句，也是死循环
  6. }

注意：

while(循环条件)中循环条件必须是boolean类型

执行流程：

  • 第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；

    • 如果是true，执行第二步；
    • 如果是false，循环语句中止，循环不再执行。
  • 第二步：执行循环体语句②；
  • 第三步：循环体语句执行完后，重新从第一步开始再执行一遍

2、while循环语句扩展格式：

  1. 初始化语句①；
  2. while (循环条件语句②) {
  3.     循环体语句③；
  4.     迭代语句④；
  5. }

执行流程：

  • 第一步：执行初始化语句①，完成循环变量的初始化；

  • 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

    • 如果是true，执行第三步；
    • 如果是false，循环语句中止，循环不再执行。
  • 第三步：执行循环体语句③
  • 第四步：执行迭代语句④，针对循环变量重新赋值
  • 第五步：根据循环变量的新值，重新从第二步开始再执行一遍

语法演示案例1：求1加到100的和

  1. int sum = 0;
  2. int i = 1;
  3. while(i<=100){
  4.     sum = sum + i;
  5.     i++;
  6. }
  7. System.out.println(sum);

3.9 循环结构：do…while循环

1、do…while循环语句标准格式：

  1. do {
  2.     循环体语句①；
  3. } while (循环条件语句②)；

注意：

（1）while(循环条件)中循环条件必须是boolean类型

（2）do{}while();最后有一个分号

（3）do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

执行流程：

  • 第一步：执行循环体语句①；

  • 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

    • 如果是true，执行第三步；
    • 如果是false，循环语句终止，循环不再执行。
  • 第三步：循环条件语句执行完后，重新从第一步开始再执行一遍

2、do…while循环语句扩展格式：

  1. 初始化语句①
  2. do {
  3.     循环体语句②；
  4.     迭代语句③；
  5. } while (循环条件语句④)；

执行流程：

  • 第一步：执行初始化语句①，完成循环变量的初始化；
  • 第二步：执行循环体语句②；
  • 第三步：执行迭代语句③，针对循环变量重新赋值；

  • 第四步：执行循环条件语句④，看循环条件语句的值是true，还是false；

    • 如果是true，根据循环变量的新值，重新从第二步开始再执行一遍；
    • 如果是false，循环语句中止，循环不再执行。

语法演示案例2：输入密码和确认密码，比较是否一致

  1.     /*
  2.     输入密码和确认密码，如果两次密码一致则显示注册成功，两次密码不一致则提示重新输入
  3.     */
  4.     Scanner input = new Scanner(System.in);
  5.     String pwdOne = "";
  6.     String pwdTwo = "";
  7.     do{
  8.         System.out.println("请输入密码");
  9.         pwdOne = input.next();
  10.         System.out.println("请输入确认密码");
  11.         pwdTwo = input.next();
  12.         if(!pwdOne.equals(pwdTwo)){
  13.             System.out.println("两次密码不一致，请重新输入");
  14.         }
  15.     }while(!pwdOne.equals(pwdTwo));
  16.     System.out.println("注册成功");

练习：猜数

随机生成一个100以内的数，猜数字游戏

从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次

提示：随机数 Math.random()

double num = Math.random();// [0,1)的小数

  1.     public static void main(String[] args){
  2.         //随机生成一个100以内的整数
  3.         /*
  4.         Math.random() ==> [0,1)的小数
  5.         Math.random()* 100 ==> [0,100)的小数
  6.         (int)(Math.random()* 100) ==> [0,100)的整数
  7.         */
  8.         int num = (int)(Math.random()* 100);
  9.         //System.out.println(num);
  11.         //声明一个变量，用来存储猜的次数
  12.         int count = 0;
  14.         java.util.Scanner input = new java.util.Scanner(System.in);
  15.         int guess;//提升作用域
  16.         do{
  17.             System.out.print("请输入100以内的整数：");
  18.             guess = input.nextInt();
  20.             //输入一次，就表示猜了一次
  21.             count++;
  23.             if(guess > num){
  24.                 System.out.println("大了");
  25.             }else if(guess < num){
  26.                 System.out.println("小了");
  27.             }
  28.         }while(num != guess);
  30.         System.out.println("一共猜了：" + count+"次");
  32.     }

3.10 循环语句：for循环

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要通过修改循环变量使得循环判断条件为false，从而结束循环，否则循环将一直执行下去，形成死循环。

1、for循环语句格式：

  1. for(初始化语句①; 循环条件语句②; 迭代语句④){
  2.     循环体语句③
  3. }
  4. for(;;){
  5.     循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
  6. }

注意：

（1）for(;;)中的两个；是不能多也不能少

（2）循环条件必须是boolean类型

（3）如果循环条件语句②省略的话，就默认为循环条件成立

执行流程：

  • 第一步：执行初始化语句①，完成循环变量的初始化；

  • 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

    • 如果是true，执行第三步；
    • 如果是false，循环语句中止，循环不再执行。
  • 第三步：执行循环体语句③
  • 第四步：执行迭代语句④，针对循环变量重新赋值
  • 第五步：根据循环变量的新值，重新从第二步开始再执行一遍

语法演示案例3：求出1-100之间偶数和

  1. /*
  2.  * 练习：求出1-100之间偶数和
  3.  * 
  4.  * 分析：
  5.  *         1.定义求和变量，初始化值是0
  6.  *         2.获取1-100之间的数据，用for循环实现
  7.  *         3.把获取到的数据进行判断，看是否是偶数
  8.  *             如果是，就累加
  9.  *         4.输出求和结果
  10.  */
  11. public class ForTest03 {
  12.     public static void main(String[] args) {
  13.         //定义求和变量，初始化值是0
  14.         int sum = 0;
  16.         //获取1-100之间的数据，用for循环实现
  17.         for(int x=1; x<=100; x++) {
  18.             //把获取到的数据进行判断，看是否是偶数
  19.             if(x % 2 == 0) {
  20.                 sum += x;
  21.             }
  22.         }
  24.         //输出求和结果
  25.         System.out.println("sum:"+sum);
  26.     }
  27. }

3.11 循环语句的区别

  • 从循环次数角度分析

    • do…while循环至少执行一次循环体语句
    • for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句

  • 从循环变量的生命周期角度分析

    • for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；
    • while和do…while循环的循环变量因为在外面声明的，所以while和do…while结束后可以被继续使用的；

  • 如何选择

    • 遍历有明显的循环次数（范围）的需求，选择for循环
    • 遍历没有明显的循环次数（范围）的需求，循环while循环
    • 如果循环体语句块至少执行一次，可以考虑使用do…while循环
    • 本质上：三种循环之间是可以互相转换的，都能实现循环的功能

  • 三种循环结构都具有四要素：

    • （1）循环变量的初始化表达式
    • （2）循环条件
    • （3）循环变量的修改的迭代表达式
    • （4）循环体语句块

3.12 控制语句

3.12.1 break

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

    • 在选择结构switch语句中

    • 在循环语句中

    • 离开使用场景的存在是没有意义的

语法案例演示1：判断某个数是否是素数

案例：从键盘输入一个大于1的自然数，判断它是否是素数
提示：素数是指大于1的自然数中，除了1和它本身以外不能再有其他因数的自然数，即某个素数n，在[2,n-1]范围内没有其他自然数可以把n整除

  1. class Test07BreakExer1{
  2.     public static void main(String[] args){
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  5.         int num;
  6.         while(true){
  7.             //true是常量，常量是编译期间就可以确定的值
  8.             System.out.print("请输入一个大于1的自然数：");
  9.             num = input.nextInt();
  11.             if(num>1){
  12.                 break;
  13.             }
  14.         }
  15.         System.out.println("num = " + num);
  17.         boolean flag = true;//假设num是素数
  19.         //判断它是否是素数
  20.         for(int i=2; i<num; i++){
  21.             if(num % i ==0){//num被某个i整除了，num就不是素数
  22.                 System.out.println(num + "不是素数");
  23.                 flag = false;
  24.                 break;//找到其中一个可以把num整除的数，就可以结束了，因为num已经可以判定不是素数了
  25.             }
  26.         }
  28.         //只有把[2,num-1]之间的所有数都检查过了，才能下定结论，num是素数
  29.         if(flag){
  30.             System.out.println(num + "是素数");
  31.         }
  33.     }
  34. }
  1. class Test07BreakExer1_2{
  2.     public static void main(String[] args){
  3.         java.util.Scanner input = new java.util.Scanner(System.in);
  5.         int num;
  6.         while(true){
  7.             //true是常量，常量是编译期间就可以确定的值
  8.             System.out.print("请输入一个大于1的自然数：");
  9.             num = input.nextInt();
  11.             if(num>1){
  12.                 break;
  13.             }
  14.         }
  15.         System.out.println("num = " + num);
  17.         boolean flag = true;//假设num是素数
  19.         //判断它是否是素数
  20.         //在[2, num的平方根]之间如果都没有一个自然数可以把num整除，那么num就是素数
  21.         /*
  22.         不是素数
  23.         9的平方根是3，除1和它本身外的因数：3
  24.         16的平方根是4，除1和它本身外的因数：2,4,8
  25.         25的平方根是5，除1和它本身外的因数：5
  26.         是素数
  27.         7的平方根是2.64，除1和它本身外的只需要判断2，如果2不是，那么就不是
  28.                 无须判断，3,4,5,6
  29.         */
  30.         for(int i=2; i<=Math.sqrt(num); i++){
  31.             if(num % i ==0){
  32.                 System.out.println(num + "不是素数");
  33.                 flag = false;
  34.                 break;
  35.             }
  36.         }
  38.         System.out.println(num + (flag?"是":"不是") + "素数");
  39.     }
  40. }

语法案例演示2：统计正数、负数个数

案例：从键盘输入不断输入整数，输入0表示结束，统计一共有几个正数、负数。

  1.     public static void main(String[] args) {
  2.         java.util.Scanner input = new java.util.Scanner(System.in);
  4.         int positive = 0;
  5.         int negative = 0;
  6.         while(true){
  7.             System.out.print("请输入整数（0）结束：");
  8.             int num = input.nextInt();
  9.             if(num==0){
  10.                 break;
  11.             }else if(num>0){
  12.                 positive++;
  13.             }else{
  14.                 negative++;
  15.             }
  16.         }
  17.         System.out.println("正数：" + positive + "，负数：" + negative);
  18.     }

语法案例演示3：break同时存在switch和循环中

===ATM=
1、存款
2、取款
3、显示余额
4、退出
请选择：

  1.     public static void main(String[] args){
  2.         java.util.Scanner input = new java.util.Scanner(System.in);
  4.         //声明一个变量表示余额
  5.         double balance = 0.0;
  6.         boolean flag = true;
  7.         while(flag){
  8.             System.out.println("=========ATM=======");
  9.             System.out.println("\t1、存款");
  10.             System.out.println("\t2、取款");
  11.             System.out.println("\t3、显示余额");
  12.             System.out.println("\t4、退出");
  13.             System.out.print("请选择：");
  14.             int select = input.nextInt();
  16.             switch(select){
  17.                 case 1:
  18.                     System.out.print("存款的金额：");
  19.                     double money = input.nextDouble();
  20.                     balance += money;
  21.                     break;
  22.                 case 2:
  23.                     System.out.print("取款的金额：");
  24.                     money = input.nextDouble();
  25.                     balance -= money;
  26.                     break;    
  27.                 case 3:
  28.                     System.out.println("现在的余额：" + balance);
  29.                     break;
  30.                 case 4:
  31.                     flag = false;
  32.                     break;//只能结束switch
  33.             }
  34.         }
  35.     }

3.12.2 continue

  • 使用场景：结束本次循环，继续下一次的循环
  1. public static void main(String[] args) {
  2.     for (int i = 1; i <= 10; i++) {
  3.         //需求:不打印3的倍数
  4.         if(i % 3 == 0){
  5.             continue;
  6.         }
  7.         System.out.println(i);
  8.     }
  9. }

练习：打印1-100之间的整数，跳过7的倍数和7结尾的数

  1.     public static void main(String[] args){
  2.         //打印1-100之间的整数，跳过7的倍数和7结尾的数
  3.         for(int i=1; i<=100; i++){
  4.             if(i%7==0 || i%10==7){
  5.                 continue;
  6.                 //break;
  7.             }
  8.             System.out.println(i);
  9.         }
  10.     }

3.13 嵌套循环

  • 所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数。当然可以是三种循环任意互相嵌套。
  • 嵌套循环格式：
  1. for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
  2.     for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
  3.           循环体语句⑤;
  4.     }
  5. }

语法案例演示1：打印5行5列矩形

  1.     public static void main(String[] args){
  2.         for (int i = 0; i < 5; i++) {
  3.             for (int j = 0; j < 5; j++) {
  4.                 System.out.print("*");
  5.             }
  6.             System.out.println();
  7.         }
  8.     }

语法案例演示2：打印5行直角三角形

  1. *
  2. **
  3. ***
  4. ****
  5. *****
  1.     public static void main(String[] args){
  2.         for (int i = 0; i < 5; i++) {
  3.             for (int j = 0; j <= i; j++) {
  4.                 System.out.print("*");
  5.             }
  6.             System.out.println();
  7.         }
  8.     }

练习1：

  1. /*
  2. 1
  3. 12
  4. 123
  5. 1234
  6. 12345
  7. */
  8.     public static void main(String[] args){
  9.         //外循环控制行数
  10.         for(int i=1; i<=5; i++){
  11.             //内循环控制每一行打印的数字
  12.             /*
  13.             当i=1，外循环第1次，第1行，j=1
  14.             当i=2，外循环第2次，第2行，j=1,2
  15.             当i=3，外循环第3次，第3行，j=1,2,3
  16.             当i=4，外循环第4次，第4行，j=1,2,3,4
  17.             当i=5，外循环第5次，第5行，j=1,2,3,4,5
  18.             j=1,j<=i
  19.             */
  20.             for(int j=1; j<=i; j++){
  21.                 System.out.print(j);
  22.             }
  23.             System.out.println();
  24.         }
  25.     }

练习2：

  1. /*
  2. 1
  3. 22
  4. 333
  5. 4444
  6. 55555
  7. */
  8.     public static void main(String[] args){
  9.         for(int i=1; i<=5; i++){
  10.             //内循环控制每一行打印的数字
  11.             /*
  12.             当i=1，外循环第1次，第1行，1，        1个i，j=1
  13.             当i=2，外循环第2次，第2行，22        2个i，j=1,2
  14.             当i=3，外循环第3次，第3行，333        3个i，j=1,2,3
  15.             当i=4，外循环第4次，第4行，4444        4个i，j=1,2,3,4
  16.             当i=5，外循环第5次，第5行，55555    5个i，j=1,2,3,4,5
  17.             说明，打印的是i的值，打印几个i
  18.             j=1,j<=i
  19.             */
  20.             for(int j=1; j<=i; j++){
  21.                 System.out.print(i);
  22.             }
  23.             System.out.println();
  24.         }
  25.     }