01分支语句switch

  1. public class Demo1Switch {
  2.     /*
  3.         格式：
  4.             switch(表达式) {
  5.                 case 值1：
  6.                     语句体1;
  7.                     break;
  8.                 case 值2：
  9.                     语句体2;
  10.                     break;
  11.                     …
  12.                 default：    
  13.                     语句体n+1;
  14.                     [break;]
  15.             }
  17.         1. 首先计算表达式的值。
  18.         2. 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句
  19.             在执行的过程中，遇到break就会结束。
  20.         3. 如果所有的case后面的值和表达式的值都不匹配
  21.             就会执行default里面的语句体，然后程序结束掉。
  23.         需求: 根据week变量记录的数值, 程序输入对应的星期
  24.         例如: int week = 1;        星期一
  25.     */
  26.     public static void main(String[] args){
  27.         int week = 100;
  29.         switch(week){
  30.             case 1 :
  31.                 System.out.println("星期一");
  32.                 break;
  33.             case 2 :
  34.                 System.out.println("星期二");
  35.                 break;
  36.             case 3 :
  37.                 System.out.println("星期三");
  38.                 break;
  39.             case 4 :
  40.                 System.out.println("星期四");
  41.                 break;
  42.             case 5 :
  43.                 System.out.println("星期五");
  44.                 break;
  45.             case 6 :
  46.                 System.out.println("星期六");
  47.                 break;
  48.             case 7 :
  49.                 System.out.println("星期日");
  50.                 break;
  51.             default:
  52.                 System.out.println("您的数据有误");
  53.                 break;
  54.         }
  55.     }
  57. }

02switch案例减肥计划

  1. import java.util.Scanner;
  3. public class TestSwitch {
  4.     /*
  5.         需求：键盘录入星期数，显示今天的减肥活动。
  8.         周一：跑步  
  9.         周二：游泳  
  10.         周三：慢走  
  11.         周四：动感单车
  12.         周五：拳击  
  13.         周六：爬山  
  14.         周日：好好吃一顿 
  16.         分析：
  17.             1. 键盘录入星期数据，使用变量接收
  18.             2. 多情况判断，采用switch语句实现
  19.             3. 在不同的case中，输出对应的减肥计划
  20.     */
  21.     public static void main(String[] args){
  22.         // 1. 键盘录入星期数据，使用变量接收
  23.         Scanner sc = new Scanner(System.in);
  24.         System.out.println("请输入");
  25.         int week = sc.nextInt();
  26.         // 2. 多情况判断，采用switch语句实现
  27.         switch(week){
  28.             // 3. 在不同的case中，输出对应的减肥计划
  29.             case 1:
  30.                 System.out.println("跑步");
  31.                 break;
  32.             case 2:
  33.                 System.out.println("游泳");
  34.                 break;
  35.             case 3:
  36.                 System.out.println("慢走");
  37.                 break;
  38.             case 4:
  39.                 System.out.println("动感单车");
  40.                 break;
  41.             case 5:
  42.                 System.out.println("拳击");
  43.                 break;
  44.             case 6:
  45.                 System.out.println("爬山");
  46.                 break;
  47.             case 7:
  48.                 System.out.println("好好吃一顿");
  49.                 break;
  50.             default:
  51.                 System.out.println("您的输入有误");
  52.                 break;
  53.         }
  54.     }
  56. }

03switch语句case穿透

  1. import java.util.Scanner;
  3. public class Demo2Switch {
  4.     /*
  5.         需求: 键盘录入星期数，输出工作日、休息日
  6.         (1-5)工作日，(6-7)休息日
  10.         case穿透是如何产生的?
  12.             如果switch语句中,case省略了break语句, 就会开始case穿透.
  14.         现象：
  15.             当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行
  16.             直到看见break，或者将整体switch语句执行完毕，才会结束。
  18.     */
  19.     public static void main(String[] args){
  20.         Scanner sc = new Scanner(System.in);
  21.         System.out.println("请输入星期数:");
  22.         int week = sc.nextInt();
  24.         switch(week){
  25.             case 1:
  26.             case 2:
  27.             case 3:
  28.             case 4:
  29.             case 5:
  30.                 System.out.println("工作日");
  31.                 break;
  32.             case 6:
  33.             case 7:
  34.                 System.out.println("休息日");
  35.                 break;
  36.             default:
  37.                 System.out.println("您的输入有误");
  38.                 break;
  39.         }
  40.     }    
  42. }

04循环语句for循环

  1. public class Demo1For {
  4.     /*
  5.         格式：
  7.             for (初始化语句;条件判断语句;条件控制语句) {
  8.                 循环体语句;
  9.             }
  11.         执行流程：
  13.             执行初始化语句
  14.             执行条件判断语句，看其结果是true还是false
  15.                          如果是false，循环结束
  16.                          如果是true，继续执行
  17.             执行循环体语句
  18.             执行条件控制语句
  19.             回到②继续
  21.         需求: 程序模拟折返跑3次的过程
  22.     */
  24.     public static void main(String[] args){
  25.         for(int i = 1; i <= 3; i++){
  26.             System.out.println("折返跑");
  27.         }
  31.     }
  33. }

05循环输出数据1-5和5-1

  1. public class Demo2For {
  2.     /*
  3.         需求：在控制台输出1-5和5-1的数据
  6.         分析:
  8.             1. 从1开始到5结束，设置初始化从1开始
  9.             2. 设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
  10.             3. 从1到5，每次增加1，设置条件控制每次+1
  11.             4. 将反复进行的事情写入循环结构内部，打印对应数据
  13.         注意:
  14.             1. 循环中, 控制循环的变量, 可以作为逻辑组织到循环体中进行使用的.
  16.             2. 循环的 条件控制语句, 不要局限的认为只能是++
  17.     */
  18.     public static void main(String[] args) {
  19.         // 1. 从1开始到5结束，设置初始化从1开始
  20.         // 2. 设置判断条件为没有到5的时候继续执行，执行到超过5程序结束
  21.         // 3. 从1到5，每次增加1，设置条件控制每次+1
  22.         for(int i = 1; i <= 5; i++){
  23.             // 4. 将反复进行的事情写入循环结构内部，打印对应数据
  24.             System.out.println(i);        // 1 2 3
  25.         }
  27.         System.out.println("--------------");
  29.         for(int i = 5; i >= 1; i--){
  30.             System.out.println(i);        // 5 4 3..
  31.         }
  32.     }
  34. }

06循环案例求1-5的数据和

  1. public class Demo3For {
  2.     /*
  3.         需求：求1-5之间的数据和，并把求和结果在控制台输出
  6.         分析:
  7.             1. 求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
  8.             2. 在循环中初始化一个变量从1开始，不断++，增长到5
  9.             3. 循环的过程中，将能够代表(1-5)的i变量和sum进行累加 
  10.             4. 当循环执行完毕时，将最终数据打印出来
  12.         注意:
  13.             如果在今后的需求中, 看到了xxxx求和的字样, 就要定义一个求和变量
  14.                 int sum = 0;
  15.     */
  16.     public static void main(String[] args) {
  17.         // 1. 求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
  18.         int sum = 0;
  19.         // 2. 在循环中初始化一个变量从1开始，不断++，增长到5
  20.         for(int i = 1; i <= 5; i++){
  21.             // 3. 循环的过程中，将能够代表(1-5)的i变量和sum进行累加 
  22.             //sum = sum + i;
  23.             sum += i;
  24.         }
  26.         // 4. 当循环执行完毕时，将最终数据打印出来
  27.         System.out.println("数据1-5的和为:" + sum);
  28.     }
  30. }

07循环求1-100的偶数和

  1. public class Demo4For {
  2.     /*
  3.         需求：求1-100之间的偶数和，并把求和结果在控制台输出
  6.         分析:
  7.             1. 需求是要求和, 定义求和变量.
  8.             2. 循环中获取1-100之间的每一个数值
  9.             3. 循环的过程中，对每一个数值进行if判断, 判断是否是偶数 
  10.             4. 是偶数的话, 跟求和变量累加
  11.             5. 循环结束后, 打印最终结果
  13.     */
  14.     public static void main(String[] args) {
  15.         // 1. 需求是要求和, 定义求和变量.
  16.         int sum = 0;
  17.         // 2. 循环中获取1-100之间的每一个数值
  18.         for(int i = 1; i <= 100; i++){
  19.             // 3. 循环的过程中，对每一个数值进行if判断, 判断是否是偶数 
  20.             if(i % 2 == 0){
  21.                 // 4. 是偶数的话, 跟求和变量累加
  22.                 sum += i;
  23.             }
  24.         }
  26.         // 5. 循环结束后, 打印最终结果
  27.         System.out.println("1-100之间的偶数和为:" + sum);
  28.     }
  30. }

08for循环案例-水仙花数

  1. public class Demo5For {
  2.     /*
  3.         需求：在控制台输出所有的 “水仙花数”
  6.                 水仙花数是一个三位数
  7.                 水仙花数的个位、十位、百位的数字立方和等于原数
  9.         分析:
  10.             1. 通过循环获取所有的三位数100-999
  11.             2. 将每一个三位数拆分为个位, 十位, 百位
  12.             3. 加入if判断条件, 计算是否是水仙花数, 是的话输出打印.
  14.     */
  15.     public static void main(String[] args) {
  16.         // 1. 通过循环获取所有的三位数100-999
  17.         for(int i = 100; i <= 999; i++){
  18.             // 2. 将每一个三位数拆分为个位, 十位, 百位
  19.             int ge = i % 10;
  20.             int shi = i / 10 % 10;
  21.             int bai = i / 10 / 10 % 10;
  22.             // int bai = i / 100;
  23.             // 3. 加入if判断条件, 计算是否是水仙花数, 是的话输出打印.
  24.             if(    (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
  25.                 System.out.println(i);
  26.             }
  27.         }
  28.     }
  30. }

09for循环案例 每行打印两个水仙花数(统计)

  1. public class Demo6For {
  2.     /*
  3.         需求：在控制台输出所有的“水仙花数”，要求每行打印2个
  5.         System.out.print (打印内容);    打印后不换行
  6.         System.out.println(打印内容);    打印后换行
  8.         分析:
  10.             1. 定义变量count，用于保存“打印过”的数量，初始值为0
  11.             2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量+1，记录打印过的数量
  12.             3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。
  14.     */
  15.     public static void main(String[] args){
  16.         // 1. 定义变量count，用于保存“打印过”的数量，初始值为0
  17.         int count = 0;
  18.         for(int i = 100; i <= 999; i++){
  19.             int ge = i % 10;
  20.             int shi = i / 10 % 10;
  21.             int bai = i / 10 / 10 % 10;
  23.             if(    (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
  24.                 //  2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量+1，记录打印过的数量
  25.                 System.out.print(i + " ");
  26.                 count++;
  27.                 // 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行
  28.                 if(count % 2 == 0){
  29.                     System.out.println();
  30.                 }
  31.             }
  32.         }
  33.     }
  35. }

10while循环

  1. public class Demo1While {
  2.     /*
  3.         完整格式：
  6.             初始化语句;
  7.             while(条件判断语句) {
  8.                 循环体语句;
  9.                 条件控制语句;
  10.             }
  12.         执行流程：
  13.             1. 执行初始化语句
  14.             2. 执行条件判断语句，看其结果是true还是false
  15.                 如果是false，循环结束
  16.                 如果是true，继续执行
  17.             3. 执行循环体语句
  18.             4. 执行条件控制语句
  19.             5. 回到②继续
  21.         需求: 在控制台打印1-100之间所有的数
  22.         需求: 在控制台打印520次 I LOVE YOU
  23.     */
  24.     public static void main(String[] args) {
  25.         /*
  26.             for(int i = 1; i <= 100; i++){
  27.                 System.out.println(i);
  28.             }
  29.         */
  30.         int i = 1;
  31.         while(i <= 520){
  32.             System.out.println("I LOVE YOU");
  33.             i++;
  34.         }
  35.     }
  37. }

11while循环案例-珠穆朗玛峰

  1. public class Demo2While {
  2.     /*
  3.         需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
  4.         请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
  7.         步骤:
  8.             1. 定义计数器变量, 准备用于统计折叠的次数
  9.             2. 准备纸张厚度变量, 珠峰高度变量
  10.             3. 折叠的过程是多次, 所以使用循环, 不确定循环次数, 使用while循环
  11.                 进入循环的条件为(厚度没有超过珠峰的高度就折叠)
  12.             4. 每折叠一次, 计数器就要自增(查数)
  13.             5. 循环结束后, 打印计数器变量即可.
  15.     */
  16.     public static void main(String[] args){
  17.         // 1. 定义计数器变量, 准备用于统计折叠的次数
  18.         int count = 0;
  19.         // 2. 准备纸张厚度变量, 珠峰高度变量
  20.         double paper = 0.1;
  21.         int zf = 8844430;
  22.         //3. 折叠的过程是多次, 所以使用循环, 不确定循环次数, 使用while循环
  23.         //    进入循环的条件为(厚度没有超过珠峰的高度就折叠)
  24.         while(paper <= zf){
  25.             paper *= 2;
  26.             System.out.println(paper);
  27.             // 4. 每折叠一次, 计数器就要自增(查数)
  28.             count++;
  29.         }
  30.         // 5. 循环结束后, 打印计数器变量即可.
  31.         System.out.println(count);
  32.     }
  34. }

12循环语句 dowhile循环

  1. public class Demo1DoWhile {
  2.     /*
  3.         完整格式：
  4.             初始化语句;
  5.             do {
  6.                 循环体语句;
  7.                 条件控制语句;
  8.             }while(条件判断语句);
  11.         执行流程：
  12.             1.执行初始化语句
  13.             2.执行循环体语句
  14.             3.执行条件控制语句
  15.             4. 执行条件判断语句，看其结果是true还是false
  16.                 如果是false，循环结束
  17.                 如果是true，继续执行
  18.             5. 回到②继续
  20.         特点:
  21.             do..while循环, 无论循环条件是否满足, 都至少会执行一次循环体.
  23.             原因: do..while循环是从上到下依次执行.
  25.     */
  26.     public static void main(String[] args){
  27.         // 需求: 在控制台打印10次黑马程序员
  28.         int i = 11;
  29.         do {
  30.             System.out.println("黑马程序员");
  31.             i++;
  32.         }while(i <= 10);
  34.         System.out.println(i);
  35.     }
  37. }

13三种循环的区别

  1. public class Loop {
  2.     /*
  3.         for和while的区别：
  6.             条件控制语句所控制的自增变量
  7.                 因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  9.             条件控制语句所控制的自增变量
  10.                 对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
  12.     */
  13.     public static void main(String[] args){
  14.         for(int i = 1; i <= 5; i++){
  15.             // for循环内部[定义]的变量, 在循环结束后, 就会从内存中消失
  16.             System.out.println(i);
  17.         }
  18.         // System.out.println(i);    //  错误: 找不到符号i
  20.         System.out.println("--------------");
  22.         for(int i = 1; i <= 10; i++){
  23.             System.out.println(i);
  24.         }
  26.         System.out.println("--------------");
  28.         // while循环
  30.         int a = 1;
  31.         while(a <= 5){
  32.             System.out.println(a);
  33.             a++;
  34.         }
  35.         System.out.println(a + "...");
  37.     }
  39. }

14死循环

  1. public class Loop {
  2.     /*
  3.         for死循环格式 :
  6.             for(;;){
  8.             }
  10.         while死循环格式 :
  12.             while(true){
  14.             }
  16.         do..while死循环格式 :
  18.             do{
  20.             }while(true);
  24.         问题: 死循环有应用场景吗?
  27.                 例如: 键盘录入一个1-100之间的整数
  29.                 顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
  31.     */
  32.     public static void main(String[] args) {
  33.         /*
  34.         for(;;){
  35.             System.out.println("我停不下来了~");
  36.         }
  37.         */
  39.         /*
  40.         while(true){
  41.             System.out.println("我停不下来了~");
  42.         }
  43.         */
  45.         do{
  46.             System.out.println("我停不下来了~");    
  47.         }while(true);
  49.         System.out.println("看看我能被执行吗?~");    // 无法访问的语句
  50.     }
  52. }

15跳转控制语句

  1. public class Demo1Continue {
  2.     /*
  3.         continue : 跳过某次循环体内容的执行
  6.         注意：使用是基于条件控制, 在循环内部使用.
  8.         需求: 模拟电梯上行的过程 1-24层, 4层不停.
  9.     */
  10.     public static void main(String[] args){
  11.         for(int i = 1; i <= 24; i++){
  12.             if(i == 4){
  13.                 continue;
  14.             }
  15.             System.out.println(i + "层到了~");
  16.         }
  17.     }
  19. }
  1. public class Demo2Break {
  2.     /*
  3.         break : 终止循环体内容的执行
  4.         注意：使用是基于条件控制的
  5.                 break语句只能在循环和switch中进行使用.
  8.         需求: 模拟20岁工作到80岁, 60岁退休.
  9.     */
  10.     public static void main(String[] args){
  11.         for(int i = 20; i <= 80; i++){
  12.             if(i == 60){
  13.                 break;        // 结束整个循环
  14.             }
  15.             System.out.println(i + "岁正在上班");
  16.         }
  17.     }
  19. }

16减肥计划改进版-循环标号

  1. import java.util.Scanner;
  3. public class Test {
  4.     /*
  5.         需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
  8.         步骤:
  10.             1. 不明确用户操作几次, 使用死循环包裹业务逻辑
  11.             2. 匹配到0的时候，使用break结束循环死循环
  13.     */
  14.     public static void main (String[] args){
  16.         lo:while(true){
  17.             System.out.println("请输入您要查看的星期数:");
  18.             System.out.println("(如无需继续查看,请输入0退出程序)");
  20.             // 1. 键盘录入星期数据，使用变量接收
  21.             Scanner sc = new Scanner(System.in);
  22.             int week = sc.nextInt();
  23.             // 2. 多情况判断，采用switch语句实现
  24.             switch(week){
  25.                 // 3. 在不同的case中，输出对应的减肥计划
  26.                 case 0:
  27.                     System.out.println("感谢您的使用");
  28.                     break lo;
  29.                 case 1:
  30.                     System.out.println("跑步");
  31.                     break;
  32.                 case 2:
  33.                     System.out.println("游泳");
  34.                     break;
  35.                 case 3:
  36.                     System.out.println("慢走");
  37.                     break;
  38.                 case 4:
  39.                     System.out.println("动感单车");
  40.                     break;
  41.                 case 5:
  42.                     System.out.println("拳击");
  43.                     break;
  44.                 case 6:
  45.                     System.out.println("爬山");
  46.                     break;
  47.                 case 7:
  48.                     System.out.println("好好吃一顿");
  49.                     break;
  50.                 default:
  51.                     System.out.println("您的输入有误");
  52.                     break;
  53.             }
  54.         }
  58.     }
  60. }

17Random基本使用

  1. import java.util.Random;
  2. public class Demo1Random {
  3.     /*
  4.         Random : 产生随机数
  5.         1. 导包    : import java.util.Random;
  6.                     导包的动作必须出现在类定义的上面
  7.         2. 创建对象 : Random r = new Random();
  8.                     上面这个格式里面，r 是变量名，可以变，其他的都不允许变
  9.         3. 获取随机数 : int number = r.nextInt(10);    //获取数据的范围：[0,10) 包括0,不包括10
  10.                     上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变
  11.         需求: 产生随机数1-10之间的
  12.     */
  13.     public static void main(String[] args){
  14.         // 2. 创建对象
  15.         Random r = new Random();
  16.         for(int i = 1; i <= 10; i++){
  17.             // 3. 获取随机数
  18.             int num = r.nextInt(10) + 1;        // 1-10
  19.             System.out.println(num);
  20.         }
  21.     }
  22. }

18猜数字

  1. import java.util.Scanner;
  2. import java.util.Random;
  4. public class Test {
  5.     /*
  6.         需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
  7.             当猜错的时候根据不同情况给出相应的提示
  8.             如果猜的数字比真实数字大，提示你猜的数据大了
  9.             如果猜的数字比真实数字小，提示你猜的数据小了
  10.             如果猜的数字与真实数字相等，提示恭喜你猜中了
  13.         1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
  14.         2. 使用Random产生一个1-100之间的数, 作为要猜的数
  15.         3. 键盘录入用户猜的的数据
  16.         4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
  18.         5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
  19.         6. 猜对之后, break结束.
  21.     */
  22.     public static void main(String[] args){
  23.         // 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
  24.         Random r = new Random();
  25.         Scanner sc = new Scanner(System.in);
  26.         // 2. 使用Random产生一个1-100之间的数, 作为要猜的数
  27.         int randomNum = r.nextInt(100) + 1;
  29.         // 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
  30.         while(true){
  31.             // 3. 键盘录入用户猜的的数据
  32.             System.out.println("请输入您猜的数据:");
  33.             int num = sc.nextInt();
  34.             // 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
  35.             if(num > randomNum){
  36.                 System.out.println("猜大了");
  37.             }else if(num < randomNum){
  38.                 System.out.println("猜小了");
  39.             }else{
  40.                 // 6. 猜对之后, break结束.
  41.                 System.out.println("恭喜,猜中了");
  42.                 break;
  43.             }
  44.         }
  46.         System.out.println("感谢您的使用");
  48.     }
  50. }