01、 程序流程控概述

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

  • 顺序结构
  • 分支结构
  • 循环结构

1、顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
2、分支结构

  • 根据条件，选择性地执行某段代码。
  • 有if…else和switch-case两种分支语句

3、循环结构

  • 根据循环条件，重复性的执行某段代码。
  • 有while、do…while、for三种循环语句。
  • 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

02、 顺序结构

Java中定义成员变量时采用合法的前向引用。如：
image.png

03、分支语句

2.1、分支语句1：if-else结构

image.png
image.png
1、if-else使用说明：
条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量；
语句块只有一条执行语句时，一对{}可以省略，但建议保留；
if-else语句结构，根据需要可以嵌套使用；
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略；
当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓当多个条件是“包含”关系时，“小上大下/ 子上父下”。
2、练习

  1. /*
  2. 分支结构中的if-else（条件判断结构）
  3. 一、三种结构
  4. 第一种：
  5. if(条件表达式){
  6.     执行表达式
  7. }
  8. 第二种：
  9. if(条件表达式){
  10.     执行表达式1
  11. }else{
  12.     执行表达式2
  13. }
  14. 第三种：
  15. if(条件表达式){
  16.     执行表达式1
  17. }else if{
  18.     执行表达式2
  19. }else if(条件表达式){
  20.     执行表达式3
  21. }
  22. ...
  23. else{
  24.     执行表达式n
  25. }
  27. */
  28. class IfTest{
  29.     public static void main(String[] args){
  30.         //举例1
  31.         int heartBeats = 75;
  32.         if(heartBeats < 60 || heartBeats > 100){
  33.             System.out.println("需要进一步做检查");
  34.         }
  35.         System.out.println("检查结束");
  37.         //举例2
  38.         int age = 23;
  39.         if(age < 18){
  40.             System.out.println("你还可以看动画片");
  41.         }else{
  42.             System.out.println("你可以看科技电影了");
  43.         }
  45.         //举例3
  46.         if(age < 0){
  47.             System.out.println("你输入的数据不合适");
  48.         }else if(age < 18){
  49.             System.out.println("你还是个青少年");
  50.         }else if(age < 35){
  51.             System.out.println("你还是个青壮年");
  52.         }else if(age < 60){
  53.             System.out.println("你还是个中年");
  54.         }else if(age < 120){
  55.             System.out.println("你进入老年了");
  56.         }else{
  57.             System.out.println("你成仙了");
  58.         }
  59.     }
  60. }

2.1.1、输入语句

  1. /*
  2. 如何从键盘获取不同类型的变量，需要使用Scanner类
  4. 具体步骤：
  5. 1.导包：import java.util.Scanner;
  6. 2.Scanner的实例化;
  7. 3.调用Scanner类的相关方法，来获取指定的变量。
  8. */
  9. import java.util.Scanner;
  11. class IFTest{
  12.     public static void main(String[] args){
  13.         //声明一个Scanner
  14.         Scanner scan = new Scanner(System.in);
  16.         int num = scan.nextInt();
  18.         System.out.println(num);
  19.     }
  20. }
  1. /*
  2. 如何从键盘获取不同类型的变量，需要使用Scanner类
  4. 具体步骤：
  5. 1.导包：import java.util.Scanner;
  6. 2.Scanner的实例化;
  7. 3.调用Scanner类的相关方法，来获取指定的变量。
  8. */
  9. import java.util.Scanner;
  11. class IFTest{
  12.     public static void main(String[] args){
  13.         //Scanner实例化
  14.         Scanner scan = new Scanner(System.in);
  16.         System.out.println("请输入你的姓名：");
  17.         String name = scan.next();
  18.         System.out.println(name);
  20.         System.out.println("请输入你的年龄：");
  21.         int age = scan.nextInt();
  22.         System.out.println(age);
  24.         System.out.println("请输入你的体重：");
  25.         double weight = scan.nextDouble();
  26.         System.out.println(weight);
  28.         System.out.println("你是否单身？(true/false)");
  29.         boolean isLive = scan.nextBoolean();
  30.         System.out.println(isLive);
  32.         //char型的获取，Scanner没有提供相关方法，只能获取一个字符串
  33.         System.out.println("请输入你的性别：(男/女)");
  34.         String TF = scan.next();
  35.         char TFChar = TF.charAt(0);
  36.         System.out.println(TFChar);
  37.     }
  38. }

1、练习1

  1. /*
  2. 岳小鹏参加Java考试，他和父亲岳不群达成承诺：
  3. 如果：成绩为100分时，奖励一辆BMW；
  4. 成绩为(80，99]时，奖励一台iphone xs max；
  5. 当成绩为[60,80]时，奖励一个iPad；
  6. 其它时，什么奖励也没有。
  7. 请从键盘输入岳小鹏的期末成绩，并加以判断
  9. 说明：
  10. 1.else结构是可选的。
  11. 2.针对于条件表达式：
  12.     ① 如果多个条件表达式之间的关系是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓；
  13.     ② 如果多个条件表达式之间是有交集的关系，需要根据实际情况，需要考虑实际情况，考虑清楚应该将哪个结构声明在上面。
  14.     ③ 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会运行。
  15. */
  16. import java.util.Scanner;
  17. class IFTest02{
  18.     public static void main(String[] args){
  19.         Scanner scan = new Scanner(System.in);
  20.         System.out.println("请输入岳小鹏的成绩：");
  21.         int score = scan.nextInt();
  23.         if(score == 100){
  24.             System.out.println("奖励一辆BMW");
  25.         }else if(score >80 && score <=99){
  26.             System.out.println("奖励一台iphone xs max");
  27.         }else if(score >= 60 && score <= 80){
  28.             System.out.println("奖励一个iPad");
  29.         }else{
  30.             System.out.println("奖励？学习去！！！");
  31.         }
  32.     }
  33. }

2、练习2

  1. /*
  2. 编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
  3. 对它们进行排序(使用if-else if-else),并且从小到大输出。
  5. */
  6. import java.util.Scanner;
  8. class Sorting{
  9.     public static void main(String[] args){
  10.         //Scanner实例化
  11.         Scanner scan = new Scanner(System.in);
  12.         System.out.println("请输入第一个整数：");
  13.         int num1 = scan.nextInt();
  14.         System.out.println("请输入第二个整数：");
  15.         int num2 = scan.nextInt();
  16.         System.out.println("请输入第三个整数：");
  17.         int num3 = scan.nextInt();
  19.         int MaxNumber = 0;
  20.         if(num1 >= num2 ){
  21.             if(num3 >= num1){
  22.                 System.out.println(num2 + "," + num1 + "," + num3);
  23.             }else if(num3 <= num2){
  24.                 System.out.println(num3 + "," + num2 + "," + num1);
  25.             }else{
  26.                 System.out.println(num2 + "," + num3 + "," + num1);
  27.             }
  28.         }else{
  29.             if(num3 >= num2){
  30.                 System.out.println(num1 + "," + num2 + "," + num3);
  31.             }else if(num3 <= num1){
  32.                 System.out.println(num3 + "," + num1 + "," + num2);
  33.             }else{
  34.                 System.out.println(num1 + "," + num3 + "," + num2);
  35.             }
  36.         }
  37.     }
  38. }

3、练习3

  1. /*
  2. 我家的狗5岁了，5岁的狗相当于人类多大呢？
  3. 其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。
  4. 那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
  5. 如果用户输入负数，请显示一个提示信息。
  7. */
  8. import java.util.Scanner;
  10. class DogYear{
  11.     public static void main(String[] args) {
  12.         Scanner scan = new Scanner(System.in);
  13.         System.out.println("请输入狗的年龄：");
  14.         double Dyear = scan.nextDouble();
  15.         if(Dyear <= 2 &&  Dyear > 0){
  16.             System.out.println("狗的年龄等同于人的：" + Dyear * 10.5);
  17.         }else if(Dyear <= 0){
  18.             System.out.println("你输入的不正确。");
  19.         }else{
  20.             double number = 2 * 10.5 + (Dyear - 2) * 4;
  21.             System.out.println("狗的年龄等同于人的：" + number);
  22.         }        
  23.     }
  24. }

4、练习4

  1. /*
  2. 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
  3. 提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
  4. 1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
  5. 2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金3 000美元。
  6. 3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
  7. 4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
  8. 5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
  9. 提示：使用(int)(Math.random() * 90  + 10)产生随机数。
  10. Math.random() : [0,1)  * 90 [0,90) + 10 [10,100)[10,99]
  12. */
  13. import java.util.Scanner;
  15. class CaiTest{
  16.     public static void main(String[] args){
  17.         //1、随机产生一个两位数
  18.         //System.out.println(Math.random());//产生[0,1)
  19.         int number = (int)(Math.random()*90 + 10);//得到[10,99]，即[10,100)
  20.         //System.out.println(number);
  22.         int numberShi = number/10;
  23.         int numberGe = number%10;
  25.         //2、用户输入一个两位数
  26.         Scanner input = new Scanner(System.in);
  27.         System.out.print("请输入一个两位数：");
  28.         int guess = input.nextInt();
  30.         int guessShi = guess/10;
  31.         int guessGe = guess%10;
  33.         if(number == guess){
  34.             System.out.println("奖金10 000美元");
  35.         }else if(numberShi == guessGe && numberGe == guessShi){
  36.             System.out.println("奖金3 000美元");
  37.         }else if(numberShi==guessShi || numberGe == guessGe){
  38.             System.out.println("奖金1 000美元");
  39.         }else if(numberShi==guessGe || numberGe == guessShi){
  40.             System.out.println("奖金500美元");
  41.         }else{
  42.             System.out.println("没中奖");
  43.         }
  45.         System.out.println("中奖号码是：" + number);
  46.     }
  47. }

6、练习5

  1. /*
  2. 大家都知道，男大当婚，女大当嫁。
  3. 那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；
  4. 富：财富1千万以上；帅：是。如果这三个条件同时满足，则：“我一定要嫁给他!!!”
  5. 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
  6. 如果三个条件都不满足，则：“不嫁！”
  8. */
  9. import java.util.Scanner;
  11. class GaoFuTest{
  12.     public static void main(String[] args){
  13.         Scanner scan = new Scanner(System.in);
  15.         System.out.println("请输入你的身高：(cm)");
  16.         int height = scan.nextInt();
  17.         System.out.println("请输入你的财富：(千万)");
  18.         double weight = scan.nextDouble();
  19. //        System.out.println("请输入你是否帅：(true/false)");
  20. //        boolean isHandSome = scan.nextBoolean();
  22. //        if(height >= 180 && weight >= 1 && isHandSome){
  23. //            System.out.println("我一定要嫁给他!!!");
  24. //        }else if(height >= 180 || weight >= 1 || isHandSome){
  25. //            System.out.println("嫁吧，比上不足，比下有余。");
  26. //        }else{
  27. //            System.out.println("不嫁！");
  28. //        }
  30.         //方式二
  31.         System.out.println("请输入你是否帅: (是or否)");
  32.         String isHandsome = scan.next();
  34.         if(height >= 100 && weight >= 1 && isHandsome.equals("是")){
  35.             System.out.println("我一定要嫁给他!!!");
  36.         }else if(height >= 180 || weight >= 1 || isHandsome.equals("是")){
  37.             System.out.println("嫁吧，比上不足，比下有余。");
  38.         }else{
  39.             System.out.println("不嫁！");
  40.         }
  41.     }
  42. }

2.2、 分支语句2：switch-case结构

注意： switch结构中的表达式，只能是如下的六种数据类型之一：byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)
不能是：long，float，double，boolean。
image.png

  1. /*
  2. 分支结构之二：switch-case
  4. 1.格式
  5. switch(表达式){
  6. case 常量1:
  7.     执行语句1;
  8.     //break;
  9. case 常量2:
  10.     执行语句2;
  11.     //break;
  13. ...
  15. default:
  16.     执行语句n:
  17.     //break;
  18. }
  20. 2.说明:
  21. ① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，进入相应case结构中，执行相关语句。
  22.   当调用完执行语句后，则仍然继续向下执行其他case语句，直到遇到break关键字或末尾结束为止。
  24. ② break, 可以使用switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
  26. ③ switch结构中的表达式，只能是如下的六种数据类型之一：byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)
  27. ④ case 之后之能声明常量。不能声明范围。
  29. ⑤ break关键字是可选的。
  30. ⑥ default：相当于if-else结构中的else。
  31.             default 结构是可选的，而且位置是灵活的。
  32. */
  34. class SwitchTest{
  35.     public static void main(String[] args){
  37.         int number = 2;
  38.         switch(number){
  39.         case 0:
  40.             System.out.println("zero");
  41.             break;
  42.         case 1:
  43.             System.out.println("one");
  44.             break;
  45.         case 2:
  46.             System.out.println("twe");
  47.             break;
  48.         case 3:
  49.             System.out.println("three");
  50.             break;
  51.         default:
  52.             System.out.println("other");
  53.             break;
  54.         }
  56.         //*********************************
  57.         //运行报错，不能运行boolean类型
  58. /*        boolean isHandSome = true;
  59.         switch(isHandSome){
  60.         case true:
  61.             System.out.println("可乐吗？？");
  62.             break;
  63.         case false:
  64.             System.out.println("薯条吗？？");
  65.             break;
  66.         default:
  67.             System.out.println("输入有误！！！");
  68.         }
  69. */
  70.         //*********************************
  71.         String season= "summer";
  72.         switch(season) {
  73.         case"spring":
  74.             System.out.println("春暖花开");
  75.             break;
  76.         case"summer":
  77.             System.out.println("夏日炎炎");
  78.             break;
  79.         case"autumn":
  80.             System.out.println("秋高气爽");
  81.             break;
  82.         case"winter":
  83.             System.out.println("冬雪皑皑");
  84.             break;
  85.         default:
  86.             System.out.println("季节输入有误");
  87.             break;
  88.         }
  90.         //**************************************
  91.         //运行报错
  92. /*        int age = 10;
  93.         switch(age){            
  94.         case age > 18:
  95.             System.out.println("成年了");
  96.             break;
  97.         default:
  98.             System.out.println("未成年");
  99.         }    */
  100.     }
  101. }

1、练习1

  1. /*
  2. 使用switch 把小写类型的char型转为大写。只转换a, b, c, d, e. 其它的输出“other”。
  3. 提示：String word = scan.next();  char c = word.charAt(0); switch(c){}
  4. */
  5. import java.util.Scanner;
  6. class  SwitchCaseTest1{
  7.     public static void main(String[] args) {
  8.         Scanner scan = new Scanner(System.in);
  9.         String word = scan.next();  
  10.         char c = word.charAt(0); 
  11.         switch(c){
  12.         case 'a':
  13.             System.out.println("A");
  14.             break;
  15.         case 'b':
  16.             System.out.println("B");
  17.             break;
  18.         case 'c':
  19.             System.out.println("C");
  20.             break;
  21.         case 'd':
  22.             System.out.println("D");
  23.             break;
  24.         case 'e':
  25.             System.out.println("E");
  26.             break;
  27.         default:
  28.             System.out.println("other");
  29.         }
  30.     }
  31. }

2、练习2

  1. /*
  2. 对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
  4. 说明：如果switch-case语句中多个相同语句，可以进行合并。
  5. */
  6. class  SwitchTest1{
  7.     public static void main(String[] args){
  8.         int score = 78;
  9.         //方案一
  10.         switch(score / 10){
  11.         case 0:
  12.         case 1:
  13.         case 2:
  14.         case 3:
  15.         case 4:
  16.         case 5:
  17.             System.out.println("不合格");
  18.             break;
  19.         case 6:
  20.         case 7:
  21.         case 8:
  22.         case 9:
  23.         case 10:
  24.             System.out.println("合格");
  25.             break;
  26.         }
  28.         //更优的解法
  29.         switch(score /60){
  30.         case 0:
  31.             System.out.println("不及格");
  32.             break;
  33.         case 1:
  34.             System.out.println("合格");
  35.             break;
  36.         }
  37.     }
  38. }

3、练习3

  1. /*
  2. 根据用于指定月份，打印该月份所属的季节。
  3. 3,4,5 春季6,7,8 夏季9,10,11 秋季12, 1, 2 冬季
  5. */
  6. class MonthTest{
  7.     public static void main(String[] args){
  8.         int month = 6;
  9.         switch(month){
  10.         case 12:
  11.         case 1:
  12.         case 2:
  13.             System.out.println("冬季");
  14.             break;
  15.         case 3:
  16.         case 4:
  17.         case 5:
  18.             System.out.println("春季");
  19.             break;
  20.         case 6:
  21.         case 7:
  22.         case 8:
  23.             System.out.println("夏季");
  24.             break;
  25.         case 9:
  26.         case 10:
  27.         case 11:
  28.             System.out.println("秋季");
  29.             break;
  30.         }
  31.     }
  32. }

4、练习4

  1. /*
  2. 编写程序：从键盘上输入2020年的“month”和“day”，
  3. 要求通过程序输出输入的日期为2019年的第几天。
  4. 2 15 : 31 + 15
  6. 5 7: 31 + 28 +31 +30 + 7
  7. ...
  8. 说明：break在switch-case中是可选的。
  9. */
  10. import java.util.Scanner;
  11. class DayTest{
  12.     public static void main(String[] args) {
  13.         Scanner scan = new Scanner(System.in);
  14.         System.out.println("请输入2020年的month");
  15.         int month = scan.nextInt();
  16.         System.out.println("请输入2020年的day");
  17.         int day = scan.nextInt();
  19.         //定义一个变量来保存天数
  20.         int sumDays = 0;
  21.         switch(month){
  22.         case 12:
  23.             sumDays += 30;
  24.         case 11:
  25.             sumDays += 31;
  26.         case 10:
  27.             sumDays += 30;
  28.         case 9:
  29.             sumDays += 31;
  30.         case 8:
  31.             sumDays += 31;
  32.         case 7:
  33.             sumDays += 30;
  34.         case 6:
  35.             sumDays += 31;
  36.         case 5:
  37.             sumDays += 30;
  38.         case 4:
  39.             sumDays += 31;
  40.         case 3:
  41.             sumDays += 29;
  42.         case 2:
  43.             sumDays += 31;
  44.         case 1:
  45.             sumDays += day;
  46.         }
  48.         System.out.println("2020年" + month + "月" + day + "日是当年的第" + sumDays + "天");
  49.     }
  50. }

5、练习5

  1. /*
  2. 从键盘分别输入年、月、日，判断这一天是当年的第几天注：判断一年是否是闰年的标准：
  3. 1）可以被4整除，但不可被100整除或
  4. 2）可以被400整除
  5. (year % 4 == 0 && year % 100 != 0) || year %400 == 0)
  7. 说明:
  8. 1凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
  9. 2.我们写分支结构时,当发现既可以使用switch-case,〔(同时,switch中表达式的取值情况不太多),
  10. 又可以使用，我们优先选择使用switch-case。原因:switch-case执行效率稍高。
  12. */
  13. import java.util.Scanner;
  14. class YearDayTest{
  15.     public static void main(String[] args) {
  16.         Scanner scan = new Scanner(System.in);
  17.         System.out.println("请输入year");
  18.         int year = scan.nextInt();
  19.         System.out.println("请输入month");
  20.         int month = scan.nextInt();
  21.         System.out.println("请输入day");
  22.         int day = scan.nextInt();
  24.         //定义一个变量来保存天数
  25.         int sumDays = 0;
  26.         switch(month){
  27.         case 12:
  28.             sumDays += 30;
  29.         case 11:
  30.             sumDays += 31;
  31.         case 10:
  32.             sumDays += 30;
  33.         case 9:
  34.             sumDays += 31;
  35.         case 8:
  36.             sumDays += 31;
  37.         case 7:
  38.             sumDays += 30;
  39.         case 6:
  40.             sumDays += 31;
  41.         case 5:
  42.             sumDays += 30;
  43.         case 4:
  44.             sumDays += 31;
  45.         case 3:
  46.             //判断是否为闰年
  47.             if((year % 4 == 0 && year % 100 != 0) || year %400 == 0){
  48.                 sumDays += 29;
  49.             }else{
  50.                 sumDays += 28;
  51.             }
  52.         case 2:
  53.             sumDays += 31;
  54.         case 1:
  55.             sumDays += day;
  56.         }
  58.         System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
  59.     }
  60. }

6、练习六

  1. /*
  2. 编写一个程序，为一个给定的年份找出其对应的中国生肖。
  3. 中国的生肖基于12年一个周期，每年用一个动物代表：
  4. rat、ox、tiger、rabbit、dragon、snake、horse、sheep、monkey、rooster、dog、pig。
  5. 提示：2019年：猪2019 % 12 == 3
  6. */
  7. import java.util.Scanner;
  8. class ZodiacSignTest{
  9.     public static void main(String[] args){
  10.         Scanner scan = new Scanner(System.in);
  11.         System.out.println("请输入年份：");
  12.         int year = scan.nextInt();
  13.         switch (year % 12){
  14.         case 1:
  15.             System.out.println("rooster");
  16.             break;
  17.         case 2:
  18.             System.out.println("dog");
  19.             break;
  20.         case 3:
  21.             System.out.println("pig");
  22.             break;
  23.         case 4:
  24.             System.out.println("rat");
  25.             break;
  26.         case 5:
  27.             System.out.println("ox");
  28.             break;
  29.         case 6:
  30.             System.out.println("tiger");
  31.             break;
  32.         case 7:
  33.             System.out.println("rabbit");
  34.             break;
  35.         case 8:
  36.             System.out.println("dragon");
  37.             break;
  38.         case 9:
  39.             System.out.println("snake");
  40.             break;
  41.         case 10:
  42.             System.out.println("horse");
  43.             break;
  44.         case 11:
  45.             System.out.println("sheep");
  46.             break;
  47.         case 12:
  48.             System.out.println("monkey");
  49.             break;
  50.         }
  51.     }
  52. }

04、循环结构

1、循环结构
在某些条件满足的情况下，反复执行特定代码的功能
2、循环语句分类

  • for 循环
  • while 循环
  • do-while 循环

image.png

4.1、for循环

  1. 语法格式
  2. for(①初始化部分;②循环条件部分;④迭代部分)｛
  3.             ③循环体部分;
  4. ｝
  7. 执行过程：①-②-③-④-②-③-④-②-③-④-.....-②
  10. 说明：
  11. ②循环条件部分为boolean类型表达式，当值为false时，退出循环
  12. ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
  13. ④可以有多个变量更新，用逗号分隔

image.png

  1. /*
  2. For循环结构的使用
  3. 一、循环结构的四个要素
  4. ① 初始化条件
  5. ② 循环条件
  6. ③ 循环体
  7. ④ 迭代条件
  9. 二、for循环的结构
  10. for(①;②;④){
  11.     ③
  12. }
  13. */
  14. class ForTest{
  15.     public static void main(String[] args){
  16.         for(int i=1;i <= 5 ;i++){
  17.             System.out.println("Hello World!");
  18.         }
  20.         //练习：
  21.         int num = 1;
  22.         for(System.out.print('a');num <= 3;System.out.print('c'),num++){
  23.             System.out.print('b');
  24.         }
  26.         //遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
  27.         int sum = 0;    //记录所有偶数的和
  28.         int count = 0;
  29.         for(int i = 1;i <= 100;i++){
  30.             if(i %2 == 0){
  31.                 System.out.println(i);
  32.                 sum += i;
  33.                 count++;
  34.             }
  35.         }
  36.         System.out.println("100以内的偶数的和：" + sum);
  37.         System.out.println("个数为：" + count);
  38.     }
  39. }

1、练习1

  1. /*
  2. 编写程序从1循环到150，并在每行打印一个值，
  3. 另外在每个3的倍数行上打印出“foo”,
  4. 在每个5的倍数行上打印“biz”,
  5. 在每个7的倍数行上打印输出“baz”。
  7. */
  8. class ForTest1{
  9.     public static void main(String[] args){
  11.         for(int i = 1;i <= 150;i++ ){
  12.             System.out.print(i + " ");
  13.             if(i % 3 == 0){
  14.                 System.out.print("foo ");
  15.             }
  16.             if(i % 5 == 0){
  17.                 System.out.print("biz ");
  18.             }
  19.             if(i % 7 == 0){
  20.                 System.out.print("baz ");
  21.             }
  23.             //换行
  24.             System.out.println();
  25.         }
  26.     }
  27. }

2、练习2

  1. /*
  2. 输入两个正整数m和n，求其最大公约数和最小公倍数。
  3. 比如：12和20的最大公约数是4，最小公倍数是60。说明：break关键字的使用
  5. */
  6. import java.util.Scanner;
  7. class GnumberTest{
  8.     public static void main(String[] args){
  9.         Scanner scan = new Scanner(System.in);
  10.         System.out.println("请输入m:");
  11.         int m = scan.nextInt();
  12.         System.out.println("请输入n:");
  13.         int n = scan.nextInt();
  14.         //获取m和n的较大值
  15.         int max = (m > n) ? m : n;
  16.         //获取m和n的最小值
  17.         int min = (m < n) ? m : n;
  19.         //求最大公约数
  20.         for(int i = min;i >= 1;i--){
  21.             if(m % i == 0 && n % i == 0){
  22.                 System.out.println("m和n的最大公约数：" + i);
  23.                 break;
  24.             }
  25.         }
  27.         //求最小公倍数
  28.         for(int i = max;i <= m * n;i++){
  29.             if( i % m == 0 && i % n == 0){
  30.                 System.out.println("m和n的最小公倍数是：" + i);
  31.                 break;
  32.             }
  33.         }
  34.     }
  35. }

3、练习3

  1. /*
  2. 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
  3. 例如：153 = 1*1*1 + 3*3*3 + 5*5*5
  5. */
  6. class ForTest2{
  7.     public static void main(String[] args){
  8.         for(int i = 100;i <= 999;i++){
  9.             int a = i / 100;    //获取百位
  10.             int b = i % 100 /10;    //获取十位
  11.             int c = i % 10;    //获取个位
  12.             if(a*a*a + b*b*b + c*c*c == i){
  13.                 System.out.println("此数值为满足条件的水仙花数:" + i);
  14.             }
  15.         }
  16.     }
  17. }

4.2、while循环

语法格式

  1. ①初始化部分
  2. while(②循环条件部分)｛
  3.     ③循环体部分;
  4.     ④迭代部分;
  5. }

执行过程：①-②-③-④-②-③-④-②-③-④-…-②
说明：

  • 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  • for循环和while循环可以相互转换。 ```java public class WhileLoop { public static void main(String args[]) {
    1.   int result = 0;
    2.   int i= 1;
    3.   while(i<= 100) {
    4.       result += i;
    5.       i++;
    6.   }
    7.   System.out.println("result="+ result);
    } }
  1. 1、练习
  2. ```java
  3. /*
  4. While循环结构的使用
  5. 一、循环结构的四个要素
  6. ① 初始化条件
  7. ② 循环条件
  8. ③ 循环体
  9. ④ 迭代条件
  11. 二、while循环的结构
  12. ①初始化部分
  13. while(②循环条件部分)｛
  14.     ③循环体部分;
  15.     ④迭代部分;
  16. }
  18. 执行过程： ① - ② - ③ - ④ - ② -  ③ - ④ - ... - ② 
  20. 说明：
  21. 1.写while循环千万要小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
  22. 2.写程序要避免死循环。
  23. 3.能用while循环的，可以用for循环，反之亦然。二者可以相互转换。
  24. 区别：for循环和while循环的初始化条件部分的作用范围不同。
  26. 算法：有限性。
  27. */
  28. class WhileTest{
  29.     public static void main(String[] args){
  30.         //遍历100以内的所有偶数
  31.         int i = 1;
  32.         while(i <= 100){
  33.             if(i % 2 == 0){
  34.                 System.out.println(i);
  35.             }
  36.             i++;
  37.         }
  38.     }
  39. }

4.3、do-while循环

  1. do-while循环结构的使用
  2. 一、循环结构的四个要素
  3. ① 初始化条件
  4. ② 循环条件 --->是boolean类型
  5. ③ 循环体
  6. ④ 迭代条件
  8. 二、do-while循环的结构
  9. ①
  10. do{
  11.     ③;
  12.     ④;
  13. }while(②);
  15. 执行过程：① - ③ - ④ - ② - ① - ③ - ④ - ... - ②
  17. 说明：do-while循环至少执行一次循环体。

1、练习1

  1. class DoWhileTest{
  2.     public static void main(String[] args){
  3.         //遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数
  4.         int number = 1;
  5.         int sum = 0;    //记录总和
  6.         int count = 0;    //记录个数
  7.         do{
  8.             if(number % 2 == 0){
  9.                 System.out.println(number);
  10.                 sum += number;
  11.                 count++;
  12.             }
  13.             number++;
  14.         }while(number <= 100);
  16.         System.out.println("总和为：" + sum);
  17.         System.out.println("个数为：" + count);
  19.         //*********************************
  20.         int numb = 10;
  21.         while(numb > 10){
  22.             System.out.println("hello:while");
  23.             numb--;
  24.         }
  26.         int numb2 = 10;
  27.         do{
  28.             System.out.println("hello：do-while");
  29.             numb2--;
  30.         }while(numb2 > 10);
  31.     }
  32. }

2、练习2

  1. /*
  2. 从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
  4. 说明：
  5. 1.不在循环条件部分限制次数的结构：while(true) , for(true)
  6. 2.结束循环的几种方式：
  7.     方式一：循环条件部分返回false;
  8.     方式二：在循环体中，执行break;
  9. */
  10. import java.util.Scanner;
  11. class XunTest{
  12.     public static void main(String[] args) {
  13.         Scanner scan = new Scanner(System.in);
  14.         int Positive = 0;    //正数个数
  15.         int Negative = 0;    //负数个数
  16.         while(true){
  17.             int number = scan.nextInt();
  18.             if(number > 0){
  19.                 Positive++;
  20.             }else if(number < 0){
  21.                 Negative++;
  22.             }else{
  23.                 //一旦执行，跳出循环。
  24.                 break;
  25.             }    
  26.         }
  28.         System.out.println("正数的个数：" + Positive);
  29.         System.out.println("负数的个数：" + Negative);
  30.     }
  31. }

4.4、嵌套循环结构

1、嵌套循环(多重循环)
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
2、例题：

  1. 九九乘法表
  2. 100以内的所有质数

3、练习1

  1. /*
  2. 嵌套循环的使用
  3. 1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
  5. 2.
  6. 外层循环：循环结构B
  7. 内层循环：循环结构A
  8. 3.说明
  9. ① 内层循环遍历一遍，只相当于外层循环循环体执行了一次
  10. ② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
  12. 4.技巧
  13. 外层循环控制行数，内层循环控制列数
  14. */
  15. class  ForForTest{
  16.     public static void main(String[] args) {
  17.         //******
  18.         for(int i = 1;i <= 6;i++){
  19.             System.out.print("*");
  20.         }
  21.         System.out.println();//换行
  23.         /*
  24.         ******
  25.         ******
  26.         ******
  27.         ******
  28.         */
  29.         for(int i = 1;i <= 4;i++){  
  30.             for(int j = 1;j <= 6;j++){  
  31.                 System.out.print('*');
  32.             }
  33.             System.out.println();    //换行
  34.         }
  35.         /*
  36.         *
  37.         **
  38.         ***
  39.         ****
  40.         *****
  41.         */
  42.         for(int i = 1;i <= 5;i++){  //控制行数
  43.             for(int j = 1;j <= i;j++){  //控制列数
  44.                 System.out.print("*");
  45.             }
  46.             System.out.println();
  47.         }
  48.         /*
  49.         *****
  50.         ****
  51.         ***
  52.         **
  53.         *
  54.         */
  55.         for(int i = 1;i <= 6;i++){
  56.             for(int j = 1;j <= 6-i;j++){
  57.                 System.out.print("*");
  58.             }
  59.             System.out.println();
  60.         }
  62.         /*
  63.         *
  64.         **
  65.         ***
  66.         ****
  67.         *****
  68.         ****
  69.         ***
  70.         **
  71.         *
  72.         */
  73.         for(int i = 1;i <= 5;i++){
  74.             for(int j = 1;j <= i;j++){
  75.                 System.out.print("*");
  76.             }
  77.             System.out.println();
  78.         }
  80.         for(int i = 1;i <= 5;i++){
  81.             for(int j = 1;j <= 5-i;j++){
  82.                 System.out.print("*");
  83.             }
  84.             System.out.println();
  85.         }
  87.         //九九乘法表
  88.         for(int i = 1;i <= 9;i++){
  89.             for(int j = 1;j <= i;j++){
  90.                 System.out.print(i + "*" + j + "=" + i*j + " ");
  91.             }
  92.             System.out.println();    //换行
  93.         }
  95.     }
  96. }

练习2

  1. /*
  2. 100以内的所有质数
  3. 质数：素数，只能被1和它本身整除的自然数。
  5. 最小的质数是：2
  6. */
  7. class PrimeNuberTest{
  8.     public static void main(String[] args){
  9.         boolean isFlag = true;    //标识是否被除尽，一旦除尽，修改其值。
  11.         for(int i = 2;i <= 100;i++){    //遍历100以内的自然数
  12.             for(int j =2;j < i;j++){    //j:被i去除
  13.                 if(i % j == 0){    //i被j除尽
  14.                     isFlag = false;
  15.                 }
  16.             }
  17.             if(isFlag == true){
  18.                 System.out.println(i);
  19.             }
  21.             //重置isFlag
  22.             isFlag = true;
  23.         }
  24.     }
  25. }

练习2的优化

  1. /*
  2. 100000以内的所有质数
  3. 质数：素数，只能被1和它本身整除的自然数。
  5. 最小的质数是：2
  6. */
  8. class PrimeNuberTest{
  9.     public static void main(String[] args){
  10.         boolean isFlag = true;    //标识是否被除尽，一旦除尽，修改其值。
  11.         int count = 0;    //记录质数的个数
  13.         //获取当前时间举例1970-01-01 00:00:00 的毫秒数
  14.         long start = System.currentTimeMillis();
  16.         for(int i = 2;i <= 100000;i++){    //遍历100以内的自然数
  17.             //优化2：对本身是质数的自然数有效 5447---> 11
  18.         //    for(int j =2;j < i;j++){    //j:被i去除
  19.             for(int j =2;j <= Math.sqrt(i);j++){    //j:被i去除
  20.                 if(i % j == 0){    //i被j除尽
  21.                     isFlag = false;
  22.                     break;    //优化一：只对本身非质数的自然数是有效的。
  23.                 }
  24.             }
  25.             if(isFlag == true){
  26.             //    System.out.println(i);
  27.                 count++;
  28.             }
  30.             //重置isFlag
  31.             isFlag = true;
  32.         }
  34.         //获取当前时间举例1970-01-01 00:00:00 的毫秒数
  35.         long end = System.currentTimeMillis();
  38.         System.out.println("质数的个数:" + count);
  39.         System.out.println("所花费的时间为:" + (end - start));    //16843 --> 5447    优化一
  40.     }
  41. }

4.5、break、continue的使用

1、break的使用
break语句用于终止某个语句块的执行

  1. {    
  2.     ......
  3.     break;
  4.     ......
  5. }

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

  1. label1:    {    ......
  2. label2:        {    ......
  3. label3:            {    ......
  4.                     break label2;
  5.                     ......
  6.                 }
  7.             }
  8.         }

2、continue的使用

  • continue 语句
    • continue只能使用在循环结构中
    • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
    • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

3、return的使用

  • return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
  • 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

4、特殊流程控制语句说明

  • break只能用于switch语句和循环语句中。
  • continue 只能用于循环语句中。
  • 二者功能类似，但continue是终止本次循环，break是终止本层循环。
  • break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
  • 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。

5、练习1

  1. /*
  2. break和countinue关键字的使用
  3.                 使用范围            循环中使用的作用(不同点)    相同点
  4. break:            switch-case            结束当前循环                关键字后面不能声明执行语句
  5.                 循环结构中
  8. countinue:        循环结构中            结束当次循环                关键字后面不能声明执行语句
  10. */
  11. class BreakContinueTest{
  12.     public static void main(String[] args){
  14.         for(int i = 1;i <= 10;i++){
  15.             if(i % 4 == 0){
  16.             //    break;    //1、2、3
  17.                 continue;    //1、2、3、5、6、7、9、10
  18.             //    System.out.println("该吃饭了！！！");
  19.             }
  20.         //    System.out.println(i);
  21.         }
  22.         //********************************
  23.         for(int i = 1;i <= 4;i++){
  25.                 for(int j = 1;j <= 10; j++){
  26.                     if(i % 4 == 0){
  27.                 //        break;    //默认跳出包裹此关键字最近的一层的循环
  28.                         continue;
  29.                     }
  30.                     System.out.print(j);
  31.                 }
  32.                 System.out.println();
  33.         }
  34.     }
  35. }