顺序控制

image.png
前面定义了变量 后面才可以引用，向前引用 不是向后

分支结构

让程序有选择的的执行,分支控制有三种

1) 单分支 if
2) 双分支 if-else
3) 多分支 if-else if -….-else

单分支 if

  1. //if的快速入门
  2. import java.util.Scanner;//导入
  3. public class If01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
  8.         //则输出 "你年龄大于18,要对自己的行为负责,送入监狱"    
  9.         //
  10.         //思路分析
  11.         //1. 接收输入的年龄, 应该定义一个Scanner 对象
  12.         //2. 把年龄保存到一个变量 int age
  13.         //3. 使用 if 判断，输出对应信息
  15.         //应该定义一个Scanner 对象
  16.         Scanner myScanner = new Scanner(System.in);
  17.         System.out.println("请输入年龄");
  18.         //把年龄保存到一个变量 int age
  19.         int age = myScanner.nextInt();
  20.         //使用 if 判断，输出对应信息
  21.         if(age > 18) {
  22.             System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
  23.         }
  25.         System.out.println("程序继续...");//这一句总会执行
  28.     }
  29. }


双分支结构 if else

  1. //if-else的快速入门
  2. import java.util.Scanner;//导入
  3. public class If02 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,
  8.         //则输出 "你年龄大于18,要对
  9.         //自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了."
  11.         //
  12.         //思路分析
  13.         //1. 接收输入的年龄, 应该定义一个Scanner 对象
  14.         //2. 把年龄保存到一个变量 int age
  15.         //3. 使用 if-else 判断，输出对应信息
  17.         //应该定义一个Scanner 对象
  18.         Scanner myScanner = new Scanner(System.in);
  19.         System.out.println("请输入年龄");
  20.         //把年龄保存到一个变量 int age
  21.         int age = myScanner.nextInt();
  22.         //使用 if-else 判断，输出对应信息
  23.         if(age > 18) {
  24.             System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
  25.         } else {//双分支
  26.             System.out.println("你的年龄不大这次放过你了");
  27.         }
  29.         System.out.println("程序继续...");
  32.     }
  33. }

image.png
上面会输出 韩顺平教育
因为根据判断x>5成立 所以为真进入内层循环，外层的else “x is” + x不会执行
内层判断y>5不成立所以 x+y 不会输出 因为还在内层 会继续往下走 会输出 韩顺平教育

  1. //单分支和双分支的练习
  2. //
  3. public class IfExercise01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  8.         //编写程序，声明2个double型变量并赋值。
  9.         //判断第一个数大于10.0，且第2个数小于20.0，打印两数之和
  11.         //思路分析
  13.         double d1 = 33.5;
  14.         double d2 = 2.6;
  15.         if(d1 > 10.0 && d2 < 20.0) {
  16.             System.out.println("两个数和=" + (d1 + d2));
  17.         }
  19.         //【课后自己练】定义两个变量int，判断二者的和，
  20.         //是否能被3又能被5整除，打印提示信息
  21.         //
  22.         //思路分析
  23.         //1. 定义两个变量int num1, num2
  24.         //2. 定义一个变量 int sum = num1 + num2;
  25.         //3. sum % 3 , 5 后 等于0 说明可以整除
  26.         //4. 使用 if - else 来提示对应信息
  27.         //走代码
  28.         int num1 = 10;
  29.         int num2 = 1;
  30.         int sum = num1 + num2;
  31.         if(sum % 3 == 0 && sum % 5 == 0) {
  32.             System.out.println("和可以被3又能被5整除");
  33.         } else {
  34.             System.out.println("和不能被3和5整除..");
  35.         }
  37.         //判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
  38.         //(1)年份能被4整除，但不能被100整除；(2)能被400整除
  39.         //
  40.         //思路分析
  41.         //1. 定义 int year 保存年
  42.         //2. 年份能被4整除，但不能被100整除, 
  43.         //   => year % 4 == 0 && year % 100 != 0 
  44.         //3. 能被400整除 => year % 400 == 0
  45.         //4. 上面的 2 和  3 是 或的关系 
  46.         //代码实现
  47.         int year = 2028;
  48.         if( (year % 4 == 0 && year % 100 != 0) ||  year % 400 == 0 ) {
  49.             System.out.println(year + " 是 闰年");
  50.         } else {
  51.             System.out.println(year + " 不是 闰年");
  52.         }
  53.     }
  54. }

多分支结构

多分支演示
1) 信用分为100分时，输出 信用极好；
2) 信用分为(80，99]时，输出 信用优秀； ( ] 前开后闭合 证明大于80 小于99但包含99

3) 信用分为[60,80]时，输出 信用一般；
4) 其它情况 ，输出 信用 不及格
请从键盘输入保国的芝麻信用分，并加以判断

  1. //课堂练习
  2. import java.util.Scanner;
  3. public class If03 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         /*
  8.         输入保国同志的芝麻信用分：
  9.         如果：
  10.         信用分为100分时，输出 信用极好；
  11.         信用分为(80，99]时，输出 信用优秀；
  12.         信用分为[60,80]时，输出 信用一般；
  13.         其它情况 ，输出 信用 不及格 
  14.         请从键盘输入保国的芝麻信用分，并加以判断
  15.         假定信用分数为int
  16.          */
  18.         Scanner myScanner = new Scanner(System.in);
  19.         //接收用户输入
  20.         System.out.println("请输入信用分(1-100):");
  21.         //请思考：如果小伙伴输入的不是整数，而是hello..
  22.         //==>这里我们后面可以使用异常处理机制搞定-》老师点一下
  23.         int grade = myScanner.nextInt();
  25.         //先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误
  27.         if(grade >=1 && grade <= 100) {
  28.             //因为有4种情况，所以使用多分支
  29.             if(grade == 100) {
  30.                 System.out.println("信用极好");
  31.             } else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；
  32.                 System.out.println("信用优秀");
  33.             } else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般
  34.                 System.out.println("信用一般");
  35.             } else {//其它情况 ，输出 信用 不及格 
  36.                 System.out.println("信用不及格");
  37.             }
  39.         } else {
  40.             System.out.println("信用分需要在1-100,请重新输入:)");
  41.         }
  43.     }
  44. }

image.png

嵌套分支结构

不建议超过三层
案例
参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息

  1. //课堂练习
  2. import java.util.Scanner;
  3. public class If03 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         /*
  8.         输入保国同志的芝麻信用分：
  9.         如果：
  10.         信用分为100分时，输出 信用极好；
  11.         信用分为(80，99]时，输出 信用优秀；
  12.         信用分为[60,80]时，输出 信用一般；
  13.         其它情况 ，输出 信用 不及格 
  14.         请从键盘输入保国的芝麻信用分，并加以判断
  15.         假定信用分数为int
  16.          */
  18.         Scanner myScanner = new Scanner(System.in);
  19.         //接收用户输入
  20.         System.out.println("请输入信用分(1-100):");
  21.         //请思考：如果小伙伴输入的不是整数，而是hello..
  22.         //==>这里我们后面可以使用异常处理机制搞定-》老师点一下
  23.         int grade = myScanner.nextInt();
  25.         //先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误
  27.         if(grade >=1 && grade <= 100) {
  28.             //因为有4种情况，所以使用多分支
  29.             if(grade == 100) {
  30.                 System.out.println("信用极好");
  31.             } else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；
  32.                 System.out.println("信用优秀");
  33.             } else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般
  34.                 System.out.println("信用一般");
  35.             } else {//其它情况 ，输出 信用 不及格 
  36.                 System.out.println("信用不及格");
  37.             }
  39.         } else {
  40.             System.out.println("信用分需要在1-100,请重新输入:)");
  41.         }
  43.     }
  44. }

image.png

  1. import java.util.Scanner;
  3. public class test {
  5.     public static void main(String[] args){
  6.         Scanner myScanner = new Scanner(System.in);
  7.         System.out.println("请输入当前月份：");
  8.         int months = myScanner.nextInt();
  9.         System.out.println("请输入客户年龄：");
  10.         int age = myScanner.nextInt();
  12.         if(months > 4 &&  months < 10){
  13.             if (age >18 && age < 60){
  14.                 System.out.println("旺季销售 票价60元");
  15.             }else if(age < 18){
  16.                 System.out.println("旺季销售 儿童票半价 30元");
  17.             }else if(age > 60){
  18.                 System.out.println("旺季销售 老年票20元");
  19.             }
  21.         }else{
  22.             if(age > 18){
  23.                 System.out.println("淡季销售 票价40");
  24.             }else{
  25.                 System.out.println("淡季销售 票价20");
  26.             }
  27.         }
  32.     }
  34. }

switch结构

image.png

请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a 表示星期一，b 表示星期二 …

根据用户的输入显示相应的信息.要求使用 switch 语句完成
穿透： 如果表达式等于常量1 执行完常量1下的语句块 如果常量1 语句块下没有break 会直接执行常量2的语句块而不会判断常量2是否符合标准 常量2没有break 继续穿透
穿透是从匹配到的语句往后穿透 前面没有匹配到的不会执行

如果所有的语句都没有break 则都会执行 default也会执行

  2. import java.util.Scanner;
  3. public class Switch01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         /*
  8.         案例：Switch01.java
  9.         请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g  
  10.         a表示星期一，b表示星期二 …  
  11.         根据用户的输入显示相应的信息.要求使用 switch 语句完成
  13.         思路分析
  14.         1. 接收一个字符 , 创建Scanner对象
  15.         2. 使用switch 来完成匹配,并输出对应信息
  16.         代码
  18.          */
  19.         Scanner myScanner = new Scanner(System.in);
  20.         System.out.println("请输入一个字符(a-g)");
  21.         char c1 = myScanner.next().charAt(0);//
  22.         //在java中，只要是有值返回，就是一个表达式
  23.         switch(c1) {
  24.             case 'a' :  //这里是冒号
  25.                 System.out.println("今天星期一,猴子穿新衣");
  26.                 break;
  27.             case 'b' : 
  28.                 System.out.println("今天星期二,猴子当小二");
  29.                 break;
  30.             case 'c' : 
  31.                 System.out.println("今天星期三,猴子爬雪山..");
  32.                 break;
  33.             //.....
  34.             default:
  35.                 System.out.println("你输入的字符不正确，没有匹配的");
  36.                 // default后面可以没有 break  一样执行完退出循环
  38.         }
  40.         System.out.println("退出了switch ,继续执行程序");
  41.     }
  42. }


switch细节

image.png

  2. public class SwitchDetail { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //细节1
  8.         //表达式数据类型，应和case 后的常量类型一致，
  9.         //或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
  11.         //细节2
  12.         //switch(表达式)中表达式的返回值必须是：
  13.         //(byte,short,int,char,enum[枚举],String) 新版本好像可以string字符串？
  15.         //细节3
  16.         //case子句中的值必须是常量(1,'a')或者是常量表达式,而不能是变量
  17.         //
  18.         //细节4
  19.         //default子句是可选的，当没有匹配的case时，执行default
  20.         //如果没有default 子句，有没有匹配任何常量，则没有输出
  21.         //
  22.         //细节5
  23.         //break语句用来在执行完一个case分支后使程序跳出switch语句块；
  24.         //如果没有写break，程序会顺序执行到switch结尾,除非执行到break
  25.         char c = 'b';
  26.         char c2 = 'c';
  27.         switch(c) {
  28.             case 'a' : // case 20 不会报错  char 于int之间可以相互转换
  29.                 System.out.println("ok1");
  30.                 break;
  31.             case 'b'  : //如果这里写 case 'hello' 编译会报错 char>string报错
  32.                 System.out.println("ok2");
  33.                 break;
  34.             case c2  : //报错 这里不允许是变量名字
  35.                 System.out.println("ok2");
  36.                 break;    
  37.             default :
  38.                 System.out.println("ok3");
  39.         }
  41.         System.out.println("退出了switch,继续执行..");
  42.     }
  43. }
  2. import java.util.Scanner;
  3. public class SwitchExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  8.         //使用 switch 把小写类型的 
  9.         //char型转为大写(键盘输入)。只转换 a->A, b->B, c, d, e. 
  10.         //其它的输出 "other"。
  12.         //创建Scanner对象
  13.         Scanner myScanner = new Scanner(System.in);
  14.         System.out.println("请输入a-e");
  15.         char c1 = myScanner.next().charAt(0);
  16.         switch(c1) {
  17.             case 'a' :
  18.                 System.out.println("A");
  19.                 break;
  20.             case 'b' :
  21.                 System.out.println("B");
  22.                 break;
  23.             case 'c' :
  24.                 System.out.println("C");
  25.                 break;
  26.             case 'd' :
  27.                 System.out.println("D");
  28.                 break;
  29.             case 'e' :
  30.                 System.out.println("E");
  31.                 break;
  32.             default :
  33.                 System.out.println("你的输入有误~");
  35.         }
  38.     }
  39. }
  2. public class SwitchExercise { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //对学生成绩大于60分的，输出"合格"。低于60分的，
  8.         //输出"不合格"。(注：输入的成绩不能大于100), 提示 成绩/60
  9.         //思路分析
  10.         //  结果只有两种 一个是合格 一个是不合格 所以需要把用户输入转换
  11.         //  整型相除  没有余数和小数
  12.         //   如果成绩在 [60,100] , (int)(成绩/60) = 1 
  13.         //   如果成绩在 [0,60) , (int)(成绩/60) = 0 
  15.         //代码实现
  17.         double score = 1.1;
  19.         //使用if-else 保证输入的成绩有有效的 0-100
  20.         //看了当老师的分析和代码演示后，自己一定要独立完成（不看老韩代码，也能写）
  21.         if( score >= 0 && score <= 100) {
  22.             switch ((int)(score / 60)) {
  23.                 case 0 :
  24.                     System.out.println("不合格");
  25.                     break;
  26.                 case 1 :
  27.                     System.out.println("合格");
  28.                     break;
  29.                 // default :
  30.                 //     System.out.println("输入有误");
  31.             }
  32.         } else {
  33.             System.out.println("输入的成绩在0-100");
  34.         }
  36.         }
  39.     }
  40. }
  2. import java.util.Scanner;
  3. public class SwitchExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  8.         //根据用于指定月份，
  9.         //打印该月份所属的季节。
  10.         //3,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季 
  11.         //[课堂练习, 提示 使用穿透 ] 
  12.         //
  13.         //思路分析
  14.         //1. 创建Scanner对象， 接收用户输入
  15.         //2. 使用 int month 接收
  16.         //3. 使用switch 来匹配 ,使用穿透来完成，比较简洁
  17.         //4. 因为 3 4 5月是一个结果 所以3 4 5可以穿透 其它季节也是一样
  19.         Scanner myScanner = new Scanner(System.in);
  20.         System.out.println("输入月份");
  21.         int month = myScanner.nextInt();
  22.         switch(month) {
  23.             case 3:
  24.             case 4:
  25.             case 5: 
  26.                 System.out.println("这是春季");
  27.                 break;
  28.             case 6:
  29.             case 7:
  30.             case 8: 
  31.                 System.out.println("这是夏季");
  32.                 break;
  33.             case 9:
  34.             case 10:
  35.             case 11: 
  36.                 System.out.println("这是秋季");
  37.                 break;
  38.             case 1:
  39.             case 2:
  40.             case 12: 
  41.                 System.out.println("这是冬季");
  42.                 break;
  43.             default :
  44.                 System.out.println("你输入的月份不对(1-12)");
  45.         }
  49.     }
  50. }

switch和if的使用场景

1) 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
2) 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广

for 循环控制

让你的代码可以循环的执行
举例
打印 10 句 “你好，韩顺平教育!”。
没有循环的方法
System.out.println(“你好，韩顺平教育!”);
System.out.println(“你好，韩顺平教育!”);
…
写十行

缺点

  1. 代码很冗余 重复的代码大量出现
  2. 修改很麻烦，如果要输出1000行，再改为500行，在改10000行，修改工作量会很大。 ```java

public class For01 { 

  1. //编写一个main方法
  2. public static void main(String[] args) {
  3.     //打印10句 "你好，韩顺平教育!"
  4.     //传统的方法
  5.     // System.out.println("你好，韩顺平教育");
  6.     // System.out.println("你好，韩顺平教育");
  7.     // System.out.println("你好，韩顺平教育");
  8.     // System.out.println("你好，韩顺平教育");
  9.     // System.out.println("你好，韩顺平教育");
  10.     // System.out.println("你好，韩顺平教育");
  11.     // System.out.println("你好，韩顺平教育");
  12.     // System.out.println("你好，韩顺平教育");
  13.     // System.out.println("你好，韩顺平教育");
  14.     // System.out.println("你好，韩顺平教育");
  15.     // 
  16.     // 使用for循环控制
  17.     for( int i = 1; i <= 10; i++) { // 1（int i = 1; 变量初始化）2（ i <= 10; 循环条件)   4(i++ 循环变量迭代)
  18.         System.out.println("你好，韩顺平教育" + i); //3(System.out.println("你好，韩顺平教育" + i); 循环操作)
  19.     }
  21. }

}

  2. 1. for 关键字，表示循环控制
  3. 1.  for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
  4. 1.  循环操作 ,  这里可以有多条语句，也就是我们要循环执行的代码
  5. 1.  如果  循环操作(语句)  只有一条语句，可以省略 {}, 建议不要省略
  7. <br />
  8. <a name="OudMq"></a>
  9. ### for循环细节
  12. 1)       循环条件是返回一个布尔值的表达式<br />2)       for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
  14. 3)       循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。<br />4)       使用内存分析法，老师分析输出下面代码输出什么?
  16. 1）
  17. ```java
  19. //演示for的使用细节
  21. public class ForDetail { 
  23.     //编写一个main方法
  24.     public static void main(String[] args) {
  26.         //for(;循环判断条件;) 
  27.         //中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略
  29.         // 使用for循环控制
  30.         int i = 1; //循环变量初始化 可以写到全局 一般用于迭代的对象需要在全局使用这样的情况。
  31.         for( ; i <= 10 ; ) {
  32.             System.out.println("hello，韩顺平教育" + i);
  33.             i++; //循环变量迭代 可以写到这里
  34.         }
  35.         System.out.println("i=" + i);//11 ok 
  37.         // int j = 1;
  38.         // //补充
  39.         // for(;;) { //表示一个无限循环,死循环
  40.         //     System.out.println("ok~" + (j++));
  41.         // }
  43.     }
  44. }
  2. //演示for的使用细节
  4. public class ForDetail { 
  6.     //编写一个main方法
  7.     public static void main(String[] args) {
  9.         //循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
  10.         //循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
  11.         // 分析代码输出什么
  12.         int count = 3;
  13.         for (int i = 0,j = 0;  i < count; i++, j += 2) {
  14.             System.out.println("i=" + i + " j=" + j);
  15.         }
  17.     }
  18. }

编程思想解析
1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值

举例
打印1~100之间所有是9的倍数的整数，统计个数 及 总和
思路过程

化繁为简

(1) 先完成 输出 1-100的值

  3. public class ForExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //(1) 完成 输出 1-100的值
  9.         for(int i = 1; i <= 100; i++) {
  10.                 System.out.println("i=" + i);
  12.         }
  14.     }
  15. }

(2) 对输出结果，进行过滤，只输出9的倍数 i % 9 ==0

  3. public class ForExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //(1) 完成 输出 1-100的值
  9.         for(int i = 1; i <= 100; i++) {
  10.             if (i % 9 == 0){
  11.                 System.out.println("i=" + i);
  12.             }
  14.         }
  16.     }
  17. }

(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;

  3. public class fordetail { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //(1) 完成 输出 1-100的值
  9.         int count = 0;
  10.         for(int i = 1; i <= 100; i++) {
  11.             if (i % 9 == 0){
  12.                 System.out.println("i=" + i);
  13.                 count++;
  14.             }
  16.         }
  18.         System.out.println("count=" + count);
  19.     }
  20. }

4)总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;

  3. public class ForExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //(1) 完成 输出 1-100的值
  9.         int count = 0;
  10.         int sum = 0;
  11.         for(int i = 1; i <= 100; i++) {
  12.             if (i % 9 == 0){
  13.                 System.out.println("i=" + i);
  14.                 count++;
  15.                 sum +=i;
  16.             }
  18.         }
  20.         System.out.println("count=" + count);
  21.         System.out.println("sum=" + sum);
  22.     }
  23. }

先死后活

(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量

  3. public class ForExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //(1) 完成 输出 1-100的值
  9.         int count = 0;
  10.         int sum = 0;
  11.         int start = 10; //增加开始结束变量
  12.         int end = 500;
  13.         for(int i = start; i <= end; i++) {  //修改表达式中的开始 从固定值改为变量
  14.             if (i % 9 == 0){
  15.                 System.out.println("i=" + i);
  16.                 count++;
  17.                 sum +=i;
  18.             }
  20.         }
  22.         System.out.println("count=" + count);
  23.         System.out.println("sum=" + sum);
  24.     }
  25. }

(2) 还可以更进一步 9 倍数也做成变量 int t = 9;

  3. public class ForExercise { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //打印1~100之间所有是9的倍数的整数，统计个数  及 总和.[化繁为简,先死后活]
  8.         //老韩的两个编程思想(技巧)
  9.         //1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
  10.         //2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
  11.         //
  12.         //思路分析
  13.         //打印1~100之间所有是9的倍数的整数，统计个数  及 总和
  14.         //化繁为简
  15.         //(1) 完成 输出 1-100的值
  16.         //(2) 在输出的过程中，进行过滤，只输出9的倍数  i % 9 ==0
  17.         //(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
  18.         //(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
  19.         //先死后活
  20.         //(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
  21.         //(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
  23.         int count = 0; //统计9的倍数个数 变量
  24.         int sum = 0; //总和
  25.         int start = 10;
  26.         int end = 200;
  27.         int t = 5; // 倍数
  28.         for(int i = start; i <= end; i++) {
  29.             if( i % t == 0) { //把这里的固定值改为变量值
  30.                 System.out.println("i=" + i);
  31.                 count++;
  32.                 sum += i;//累积
  33.             }
  34.         }
  36.         System.out.println("count=" + count);
  37.         System.out.println("sum=" + sum);
  39.     }
  40. }

完成下面的表达式输出
image.png
化繁为简
先输出0-5

  1. public class ForExercise02{ 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //化繁为简
  7.         for( int i = 0; i <= 5; i++) {
  8.             System.out.println(i );
  9.         }
  10.     }
  11. }

根据图片 i + (5-i) = 5 前面的计算公式可以写成 

  1. public class ForExercise02 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //化繁为简
  7.         for( int i = 0; i <= 5; i++) {
  8.             System.out.println(i + "+" + (5-i) + "=" + 5);
  9.         }
  10.     }
  11. }

由死变活 把固定值改为变量

  1. public class ForExercise02 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //化繁为简
  7.         //先死后活 
  8.         int n = 9;
  9.         for( int i = 0; i <= n; i++) {
  10.             System.out.println(i + "+" + (n-i) + "=" + n);
  11.         }
  12.     }
  13. }

while循环

image.png

image.png

  1. //while循环的案例
  2. //
  3. public class While01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  8.         //输出10句 你好,韩顺平教育
  10.         int i = 1; //循环变量初始化
  11.         while( i <= 10 ) {//循环条件
  12.             System.out.println("你好，韩顺平教育" + i);//执行语句
  13.             i++;//循环变量迭代
  14.         }
  16.         System.out.println("退出while ，继续.." + i); // 11
  17.     }
  18. }
  2. public class WhileExercise { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         // 打印1―100之间所有能被3整除的数 [使用while, 老师评讲 ]
  8.         // 化繁为简, 先死后活
  10.         int i = 1;
  11.         int endNum = 100;
  12.         while( i <= endNum) {
  13.             if( i % 3 == 0) {
  14.                 System.out.println("i=" + i);
  15.             }
  17.             i++;//变量自增   自增是while循环自增 所以写在外面。
  18.         }
  20.         // 打印40―200之间所有的偶数 [使用while, 课后练习]
  21.         // 化繁为简, 先死后活(利于思考)
  22.         //
  23.         System.out.println("========");
  24.         int j = 40; //变量初始化
  25.         while ( j <= 200) {
  26.             //判断
  27.             if( j % 2 == 0) {
  28.                 System.out.println("j=" + j);
  29.             }
  30.             j++;//循环变量的迭代
  31.         }
  33.     }
  34. }

do..while循坏控制

循环变量初始化; do{
循环体(语句);循环变量迭代;
}while(循环条件);
image.png
do while至少先执行一次。

image.png

  3. public class DoWhile01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  9.         //输出10句 你好,韩顺平教育
  10.         int i = 1; //循环变量初始化
  11.         do {
  12.             //循环执行语句
  13.             System.out.println("你好，韩顺平教育" + i);
  14.             //循环变量迭代
  15.             i++;
  17.         }while(i <= 10);
  19.         System.out.println("退出 do..while 继续执行.." + i);//11
  20.     }
  21. }
  3. public class DoWhileExercise01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //统计1---200之间能被5整除但不能被3整除的 个数
  8.         //化繁为简
  9.         //(1) 使用do-while输出 1-200
  10.         //(2) 过滤 能被5整除但不能被3整除的数 %
  11.         //(3) 统计满足条件的个数 int count = 0; 
  12.         //先死后活
  13.         //(1) 范围的值 1-200 你可以做出变量
  14.         //(2) 能被5整除但不能被3整除的 , 5 和 3 可以改成变量 
  15.         int i = 1;
  16.         int count = 0; //统计满足条件的个数
  17.         do {
  18.             if( i % 5 == 0 && i % 3 != 0 ) {
  19.                 System.out.println("i=" + i);
  20.                 count++;
  21.             }
  22.             i++;
  23.         }while(i <= 200);
  25.         System.out.println("count=" + count);
  26.     }
  27. }
  1. import java.util.Scanner;
  2. public class DoWhileExercise02 { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
  8.         //[System.out.println("老韩问：还钱吗？y/n")]   do...while ..
  9.         //
  10.         //化繁为简
  11.         //(1) 不停的问还钱吗?
  12.         //(2) 使用char answer 接收回答, 定义一个Scanner对象
  13.         //(3) 在do-while 的while 判断如果是 y 就不在循环
  14.         //一定自己动脑筋..
  15.         Scanner myScanner  = new Scanner(System.in);
  16.         char answer = ' ';
  17.         do {
  18.             System.out.println("老韩使出五连鞭~");
  19.             System.out.println("老韩问：还钱吗？y/n");
  20.             answer = myScanner.next().charAt(0);
  21.             System.out.println("他的回答是" + answer);
  22.         }while(answer != 'y');//判断条件很关键  这个的判断条件是必须是布尔值类型 true  false 这里是继续循环需要满足的条件
  24.         System.out.println("李三还钱了");
  25.     }
  26. }

多重循环控制 难点

1) 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】

2)实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]。

设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次
image.png

image.png

  2. public class MulFor { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         for(int i = 0; i < 2; i++) { //先思考
  8.             for( int j = 0; j < 3; j++) { 
  9.                 System.out.println("i=" + i + "j=" + j);
  10.             }
  11.         }
  13.     }
  14. }
  2. import java.util.Scanner;
  3. public class MulForExercise01 { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         //统计3个班成绩情况，每个班有5名同学，
  8.         //求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
  9.         //统计三个班及格人数，每个班有5名同学。
  10.         //
  11.         //思路分析:
  12.         //化繁为简
  13.         //(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
  14.         //1.1 创建 Scanner 对象然后，接收用户输入
  15.         //1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级5个学生的成绩累积 
  17.         //(2) 统计3个班(每个班5个学生) 平均分
  18.         //(3) 所有班级的平均分
  19.         //3.1 定义一个变量，double totalScore 累积所有学生的成绩
  20.         //3.2 当多重循环结束后，totalScore / (3 * 5) 
  21.         //(4) 统计三个班及格人数
  22.         //4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
  23.         //4.2 如果 >= 60 passNum++
  24.         //(5) 可以优化[效率，可读性, 结构]
  26.         //创建 Scanner 对象
  27.         Scanner myScanner = new Scanner(System.in);
  28.         double totalScore = 0; //累积所有学生的成绩
  29.         int passNum = 0;//累积 及格人数
  30.         int classNum = 3; //班级个数
  31.         int stuNum = 5;//学生个数
  32.         for( int i = 1; i <= classNum; i++) {//i 表示班级
  34.             double sum = 0; //一个班级的总分
  35.             for( int j = 1; j <= stuNum; j++) {//j 表示学生
  36.                 System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
  37.                 double score = myScanner.nextDouble();
  38.                 //当有一个学生成绩>=60, passNum++
  39.                 if(score >= 60) {
  40.                     passNum++;
  41.                 }
  42.                 sum += score; //累积
  43.                 System.out.println("成绩为" + score);
  44.             }
  45.             //因为sum 是 5个学生的总成绩
  46.             System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));
  47.             //把 sum 累积到 totalScore
  48.             totalScore += sum;
  50.         }
  51.         System.out.println("三个班总分="+ totalScore 
  52.             + " 平均分=" + totalScore / (classNum*stuNum));
  53.         System.out.println("及格人数=" + passNum);
  55.     }
  56. }

image.png

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

打印空心金字塔

化繁为简 分解步骤

  1. 先打印五行* ```java public class fordetail { public static void main(String[] args) {

    1.  for(int i = 1; i <=5; i++){
    2.      System.out.println("*****"); //println会自动换行
    3.  }

    } }

  4. 2. 打印半个金字塔<br />分解过程<br />  *        //第1层 有 1个*<br />  **    //第2层 有 2个*<br />  ***  //第3层 有 3个*<br />  ****    //第4层 有 4个*<br />  *****   //第5层 有 5个*
  5. ```java
  6. public class fordetail { 
  7.     public static void main(String[] args) {
  9.         for(int i = 1; i <=5; i++){
  10.             //内循环控制打印*的个数
  11.             for (int j=1; j<=i;j++){
  12.                 System.out.print("*");
  13.             }//每打印完一个内循环就换行
  14.             System.out.println(""); 
  15.         }
  17.     }
  18. }
  1.  3. 打印整个金字塔<br />分解过程<br />      *       //第1层 有 1个*   2 * 1 -1   有4=(总层数-1)个空格 <br />    ***      //第2层 有 3个*   2 * 2 -1   有3=(总层数-2)个空格<br />   *****     //第3层 有 5个*   2 * 3 -1   有2=(总层数-3)个空格<br />  *******    //第4层 有 7个*   2 * 4 -1   有1=(总层数-4)个空格<br />*********   //第5层 有 9个*   2 * 5 -1   有0=(总层数-5)个空格<br />不计算空格的编码
  1. public class fordetail { 
  2.     public static void main(String[] args) {
  4.         for(int i = 1; i <=5; i++){
  5.             //内循环控制打印*的个数
  6.             for (int j=1; j<=2*i-1;j++){ // 2 * 层数 -1
  7.                 System.out.print("*");
  8.             }//每打印完一个内循环就换行
  9.             System.out.println("");
  10.         }
  12.     }
  13. }

加上空格 输出实心三角形

  3. public class fordetail { 
  4.     public static void main(String[] args) {
  6.         for(int i = 1; i <=5; i++){ 
  8.             for (int k =1; k<= 5-i;k++){  // (总层数-1)个空格
  9.                 System.out.print(" ");
  10.             }
  12.             //内循环控制打印*的个数
  13.             for (int j=1; j<=2*i-1;j++){
  14.                 System.out.print("*");
  15.             }//每打印完一个内循环就换行
  16.             System.out.println("");
  17.         }
  19.     }
  20. }
  1.  4. 打印空心的金字塔 [最难的]<br />     *       //第1层 有 1个*   当前行的第一个位置是*,最后一个位置也是*<br />    * *      //第2层 有 2个*   当前行的第一个位置是*,最后一个位置也是*<br />   *   *     //第3层 有 2个*   当前行的第一个位置是*,最后一个位置也是*<br />  *     *    //第4层 有 2个*   当前行的第一个位置是*,最后一个位置也是*<br />*********   //第5层 有 9个*   全部输出*
  3. public class fordetail { 
  4.     public static void main(String[] args) {
  6.         for(int i = 1; i <=5; i++){
  8.             for (int k =1; k<= 5-i;k++){
  9.                 System.out.print(" ");
  10.             }
  12.             //内循环控制打印*的个数
  13.             for (int j=1; j<=2*i-1;j++){
  14.                 if (j == 1 || j == 2*i-1 || i == 5){ // 通过一个for循环判断是第1个 最后一个 和总数为5输出*
  15.                     System.out.print("*");
  16.                 }else{
  17.                     System.out.print(" "); //其余情况输出空格填充
  19.                 }
  21.             }//每打印完一个内循环就换行
  22.             System.out.println(""); 
  23.         }
  25.     }
  26. }

5先死后活 把固定值改为变量

  3. public class Stars { 
  5.     //编写一个main方法
  6.     public static void main(String[] args) {
  7.         /*
  8.         先死后活
  9.         5 层数做成变量 int totalLevel = 5;
  11.          */
  12.         int totalLevel = 20; //层数
  13.         for(int i = 1; i <= totalLevel; i++) { //i 表示层数
  15.             //在输出*之前，还有输出 对应空格 = 总层数-当前层
  16.             for(int k = 1; k <= totalLevel - i; k++ ) {
  17.                 System.out.print(" ");
  18.             }
  20.             //控制打印每层的*个数
  21.             for(int j = 1;j <= 2 * i - 1;j++) {
  22.                 //当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
  23.                 if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
  24.                     System.out.print("*");
  25.                 } else { //其他情况输出空格
  26.                     System.out.print(" ");
  27.                 }
  28.             }
  29.             //每打印完一层的*后，就换行 println本身会换行
  30.             System.out.println("");
  31.         }
  32.     }
  33. }