diff --git "a/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md" "b/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..69693182069c22aa749fb786191db69e453a008a
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md"	
@@ -0,0 +1,185 @@
+# Random产生随机数
+
+##### **概述： Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能 API后续课程详细讲解，现在可以简单理解为Java已经写好的代码 使用步骤：**
+
+##### ** 1. 导入包 import java.util.Random;
+
+##### 2. 创建对象 Random r = new Random(); 3
+
+##### . 产生随机数 int num = r.nextInt(10); 解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随 机数则是0-19
+
+##### 示例代码：**
+
+```java
+import java.util.Random;
+public class Demo1Random { 
+    /* Random : 产生随机数 
+    1. 导包 : import java.util.Random; 导包的动作必须出现在类定义的上面 
+    2. 创建对象 : Random r = new Random(); 上面这个格式里面，r 是变量名，可以变，其他的都不允许变 
+    3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包 括0,不包括10 上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不 允许变 
+    需求: 产生随机数1-10之间的 */ public static void main(String[] args){ // 
+        2. 创建对象 Random r = new Random(); for(int i = 1; i <= 10; i++){ //
+            3. 获取随机数 int num = r.nextInt(10) + 1; // 1-10 System.out.println(num); } } }
+```
+
+# 数组
+
+数组介绍
+
+数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。 
+
+数组的定义格式
+
+第一种格式：
+
+```java
+int[] arr;        
+double[] arr;      
+char[] arr;
+```
+
+ 第二种格式：
+
+```java
+int arr[];
+double arr[];
+char arr[];
+```
+
+数组的动态初始化
+
+什么是动态初始化：数组动态初始化就是只给定数组的长度，由系统给出默认初始化值。
+
+动态初始化格式;
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度];
+
+int[] arr = new int[3];
+```
+
+ 动态初始化格式详解
+
+- 等号左边：
+  
+  - int:数组的数据类型
+  
+  - []:代表这是一个数组
+  
+  - arr:代表数组的名称
+
+- 等号右边：
+  
+  - new:为数组开辟内存空间
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - 5:代表数组的长度
+
+**代码 :** 
+
+```java
+package com.itheima.array;
+
+public class Demo2Array {
+    /*
+        数组的动态初始化:
+                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
+
+        动态初始化格式:
+                        数据类型[] 数组名 = new 数据类型[数组的长度];
+
+        注意:
+                        打印数组变量的时候, 会打印出数组的内存地址
+
+        [I@10f87f48 :
+
+                        @ : 分隔符
+                        [ : 当前的空间是一个数组类型
+                        I : 当前数组容器中所存储的数据类型
+                        10f87f48 : 十六进制内存地址
+
+                                0 1 2 3 4 5 6 7 8 9 a b c d e f
+     */
+    public static void main(String[] args) {
+        // 数据类型[] 数组名 = new 数据类型[数组的长度];
+        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
+        int[] arr = new int[5];
+        // [I@10f87f48
+        System.out.println(arr);
+
+        byte[] bArr = new byte[3];
+        // [B@b4c966a
+        System.out.println(bArr);
+
+    }
+
+}
+```
+
+# 作业
+
+需求： 程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？ 当猜错的时候根据不同情况给出相应的提示 A. 如果猜的数字比真实数字大，提示你猜的数据大了 B. 如果猜的数字比真实数字小，提示你猜的数据小了 C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
+
+```java
+package 循环;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class d6 {
+    public static void main(String[] args) {
+        Random ran =new Random();
+        int num = ran.nextInt(100);
+        Scanner ee=new Scanner(System.in);
+        int count=0;
+        f:while (true){
+            System.out.println("请猜一个数:");
+            int ff= ee.nextInt();
+        if (ff>num){
+            System.out.println("太大了");
+        }else if (ff<num){
+            System.out.println("太小了");
+        }else {
+            System.out.println("猜对了!");
+            break;
+        }count++;
+        if (count==3){
+            System.out.println("是否还要继续，继续输入:Y/y，退出输入：N/n");
+            Scanner dd=new Scanner(System.in);
+            char answer = ee.next().charAt(0);
+             gg: switch (answer){
+                case 'Y':
+                case 'y':
+                    count=0;break gg;
+                case 'N':
+                case 'n':
+                 default:
+                    break gg;
+             }switch (answer){
+                case 'n':
+                case 'N':
+                    break f;
+            }
+            }
+
+        }
+    }
+}
+```
+
+## 作业.2
+
+```java
+public class D3 {
+    public static void main(String[] args) {
+        int[] arr = {10, 20, 30, 40, 50};
+        int da = arr[0];
+        for (int i = 1; i< arr.length; i++){
+            if (arr[i]>da){
+                da=arr[i];
+            }
+        }
+        System.out.println("最大为："+da);
+    }
+}
+```
diff --git "a/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md" "b/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md"
index 0ad3b5579981d70409e4f4de198100d99a392c64..455e95ec9789df9ca59c824433101a772ee61817 100644
--- "a/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md"	
+++ "b/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md"	
@@ -1,3 +1,5 @@
+
+
 四位数分解
 
 ```java
diff --git "a/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md" "b/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md"
new file mode 100644
index 0000000000000000000000000000000000000000..982704425b8e15d91e3d6976e55fa92295825ed9
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md"	
@@ -0,0 +1,922 @@
+# 1.switch语句
+
+#### 1.1分支语句switch语句
+
+**格式**
+
+```java
+switch (表达式){
+case 1:
+    语句体1;
+    break;
+case 2:
+    语句体2;
+    break;
+...
+    default:
+语句体n+1;
+    break;
+}
+```
+
+执行流程：
+
+* 首先计算出表达式的值
+* 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结 束。
+* 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束 掉。
+
+#### 1.2switch案例-减肥计划
+
+* 需求：键盘录入星期数，显示今天的减肥活动
+  
+  ```java
+  周一：跑步
+  周二：游泳
+  周三：慢走
+  周四：动感单车
+  周五：拳击
+  周六：爬山
+  周日：好好吃一顿
+  ```
+
+* 示例代码：
+  
+  ```java
+  public static void main(String[] args){
+  // 1. 键盘录入星期数据，使用变量接收
+  Scanner sc = new Scanner(System.in);
+  System.out.println("请输入");
+  int week = sc.nextInt();
+  // 2. 多情况判断，采用switch语句实现
+  switch(week){
+  // 3. 在不同的case中，输出对应的减肥计划
+  case 1:
+  System.out.println("跑步");
+  break;
+          case 2:
+              System.out.println("游泳");
+              break;
+          case 3:
+              System.out.println("慢走");
+              break;
+          case 4:
+              System.out.println("动感单车");
+              break;
+          case 5:
+              System.out.println("拳击");
+              break;
+          case 6:
+              System.out.println("爬山");
+              break;
+          case 7:
+              System.out.println("好好吃一顿");
+              break;
+          default:
+              System.out.println("您的输入有误");
+              break;
+          }
+      }
+  }
+  ```
+
+#### 1.3 switch语句case穿透
+
+* 概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透
+
+* 需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日
+
+* 示例代码：
+  
+  ```java
+  * /*
+    case穿透是如何产生的?
+    如果switch语句中,case省略了break语句, 就会开始case穿透.
+    现象：
+    当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行
+    直到看见break，或者将整体switch语句执行完毕，才会结束。
+    */
+    public static void main(String[] args){
+    Scanner sc = new Scanner(System.in);
+    System.out.println("请输入星期数:");
+    int week = sc.nextInt();
+    switch(week){
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    System.out.println("工作日");
+    break;
+    case 6:
+    case 7:
+    System.out.println("休息日");
+    break;
+            default:
+    System.out.println("您的输入有误");
+    break;
+            }
+        }
+    }
+  
+  ```
+
+## 2.for循环
+
+#### 2.1循环语句-for循环
+
+- 循环
+  
+  循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
+
+- for循环格式 ```java for(初始化语句；条件判断语句；条件控制语句){ 循环体语句; }
+
+- 格式解释
+* [x] 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+
+* [x] 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+
+* [x] 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+
+* [x] 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+* 执行流程
+  
+  ①执行初始化语句
+  
+  ②执行条件判断语句，看其结果是true还是false
+  
+   如果是false，循环结束
+  
+   如果是true，继续执行
+  
+  ③执行循环体语句
+  
+  ④执行条件控制语句
+  
+  ⑤回到②继续
+
+#### 2.2for循环案例-输出数据1-5和5-1
+
+* 需求：在控制台输出1-5和5-1的数据
+
+* 示例代码
+  
+  ```java
+  public class ForTest01 {
+  public static void main(String[] args) {
+  //需求：输出数据1-5
+  for(int i=1; i<=5; i++) {
+  System.out.println(i);
+  }
+  System.out.println("--------");
+  //需求：输出数据5-1
+  for(int i=5; i>=1; i--) {
+  System.out.println(i);
+          }
+      }
+  }
+  ```
+
+#### 2.3for循环案例-求1-5数据和
+
+* 需要：求1-5之间的数据和，并把求和结果在控制台输出
+
+* 示例代码：
+
+```java
+  public class ForTest02 {
+  public static void main(String[] args) {
+  //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+  int sum = 0;
+  //从1开始到5结束的数据，使用循环结构完成
+  for(int i=1; i<=5; i++) {
+  //将反复进行的事情写入循环结构内部
+  // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
+  sum += i;
+  /*
+  sum += i; sum = sum + i;
+  第一次：sum = sum + i = 0 + 1 = 1;
+  第二次：sum = sum + i = 1 + 2 = 3;
+  第三次：sum = sum + i = 3 + 3 = 6;
+  第四次：sum = sum + i = 6 + 4 = 10;
+  第五次：sum = sum + i = 10 + 5 = 15;
+  */
+  }
+  //当循环执行完毕时，将最终数据打印出来
+  System.out.println("1-5之间的数据和是：" + sum);
+      }
+  }
+```
+
+* 本题要点：
+  
+  今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
+  
+  求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+  
+  2.4for循环案例-求1-100
+
+#### 2.4for循环案例-求1-100偶数和
+
+- 需求：求1-100之间的偶数和，并把求和结果在控制台输出
+
+- 示例代码：
+
+```java
+public class ForTest03 {
+public static void main(String[] args) {
+//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+int sum = 0;
+    //对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
+for(int i=1; i<=100; i++) {
+//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
+if(i%2 == 0) {
+sum += i;
+}
+}
+//当循环执行完毕时，将最终数据打印出来
+System.out.println("1-100之间的偶数和是：" + sum);
+}
+}
+```
+
+#### 2.5 for循环案例-水仙花数
+
+- 需求：在控制台输出所有的“水仙花数”
+
+- 解释：什么是水仙花？
+  
+  - [ ] 水仙花数，指的是一个三位数，个位，十位，百位的数字立方和等于原数
+    
+    ​    例如 153 3 * 3 *  3 + 5 * 5 * 5 + 1 * 1 * 1 = 153
+
+- 思路
+  
+  1. 获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
+  2. 获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
+
+- 示例代码
+  
+  ```java
+  public class ForTest04 {
+  public static void main(String[] args) {
+  //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结
+  束
+  for(int i=100; i<1000; i++) {
+  //在计算之前获取三位数中每个位上的值
+  int ge = i%10;
+  int shi = i/10%10;
+  int bai = i/10/10%10;
+  //判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
+  if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
+  //输出满足条件的数字就是水仙花数
+  System.out.println(i);
+              }
+          }
+      }
+  }
+  ```
+  
+  #### 2.6循环案例-每行打印2个水仙花数（统计）
+
+- 需求：在控制台输出所有的“水仙花数”，要求每行打印2个
+
+- 示例代码：
+  
+  ```java
+  public class Demo6For {
+  /*
+  需求：在控制台输出所有的“水仙花数”，要求每行打印2个
+  System.out.print (打印内容); 打印后不换行
+  System.out.println(打印内容); 打印后换行
+  分析:
+  1. 定义变量count，用于保存“打印过”的数量，初始值为0
+  2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量
+  +1，记录打印过的数量
+  3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。
+  */
+  public static void main(String[] args){
+  // 1. 定义变量count，用于保存“打印过”的数量，初始值为0
+  int count = 0;
+  for(int i = 100; i <= 999; i++){
+  int ge = i % 10;
+  int shi = i / 10 % 10;
+  int bai = i / 10 / 10 % 10;
+  if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
+  // 2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让
+  count变量+1，记录打印过的数量
+  System.out.print(i + " ");
+  count++;
+  // 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行
+  if(count % 2 == 0){
+  System.out.println();
+              }
+  }
+  }
+  }
+  }
+  
+  ```
+
+- 本题要点：
+
+- [ ] 今后如果需求带有统计xxx，请先想到计数器变量
+
+- [ ] 计数器变量定义的位置，必须在循环外部
+
+## 3.while循环
+
+#### 3.1循环语句-while循环
+
+- while循环完整格式：
+  
+  ```java
+  初始化语句;
+  while (条件判断语句) {
+  循环体语句;
+  条件控制语句;
+  }
+  ```
+
+- while循环执行流程：
+1. 执行初始化语句
+
+2. 执行条件判断语句，看其结果是true还是
+   
+   如果是false，循环结束
+   
+   如果是true，继续执行
+
+3. 执行循环体语句
+
+4. 执行条件控制语句
+
+5. 回到2.继续
+- 示例代码
+  
+  ```java
+  public class WhileDemo {
+  public static void main(String[] args) {
+  //需求：在控制台输出5次"HelloWorld"
+  //for循环实现
+  for(int i=1; i<=5; i++) {
+  System.out.println("HelloWorld");
+  }
+  System.out.println("--------");
+  //while循环实现
+  int j = 1;
+  while(j<=5) {
+  System.out.println("HelloWorld");
+  j++;
+  }
+  }
+  }
+  ```
+
+3.2while循环案例-珠穆朗玛峰
+
+- 需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，他的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
+
+- 示例代码：
+  
+  ```java
+  public class WhileTest {
+  public static void main(String[] args) {
+  //定义一个计数器，初始值为0
+  int count = 0;
+  //定义纸张厚度
+  double paper = 0.1;
+  //定义珠穆朗玛峰的高度
+  int zf = 8844430;
+  //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while
+  循环
+  //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
+  while(paper <= zf) {
+  //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
+  paper *= 2;
+  //在循环中执行累加，对应折叠了多少次
+  count++;
+  }
+  //打印计数器的值
+  System.out.println("需要折叠：" + count + "次");
+  }
+  }
+  ```
+
+## 4.循环细节
+
+#### 4.1循环语句-dowhile循环
+
+- 完整格式
+  
+  ```java
+  初始化语句；
+  do{
+      循环体语句；
+      条件控制语句；
+  }wwhile（条件判断语句）；
+  ```
+
+- 执行流程
+  
+  1.执行初始化语句
+  
+  2.执行循环体语句
+  
+  3.执行条件控制语句
+  
+  4.执行条件判断语句，看其结果是true还是
+  
+   如果是false，循环结束
+  
+  如果是true，循环继续
+  
+  5.回到2.继续
+
+- 示例代码
+  
+  ```java
+  public class DoWhileDemo {
+  public static void main(String[] args) {
+  //需求：在控制台输出5次"HelloWorld"
+  //for循环实现
+  for(int i=1; i<=5; i++) {
+  System.out.println("HelloWorld");
+  }
+  System.out.println("--------");
+  //do...while循环实现
+  int j = 1;
+  do {
+  System.out.println("HelloWorld");
+  j++;
+  }while(j<=5);
+      }
+  }
+  ```
+
+#### 4.2三种循环的区别
+
+- 三种循环的区别
+  
+  for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
+  
+  do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
+
+- for循环和while的区别
+  
+  条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
+  
+  条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
+
+- 死循环（无限循环）的三种格式
+  
+  1.for(;;){}
+  
+  2.while(true){}
+  
+  3.do {} while(true);
+
+#### 4.3死循环
+
+- 死循环格式
+  
+  ```java
+  for死循环格式 :
+  for(;;){
+  }
+  while死循环格式 :
+  while(true){
+  }
+  do..while死循环格式 :
+  do{
+  }while(true);
+  
+  ```
+
+- 死循环案例
+
+```java
+/*
+问题: 死循环有应用场景吗?
+例如: 键盘录入一个1-100之间的整数
+顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
+*/
+public static void main(String[] args) {
+/*
+for(;;){
+System.out.println("我停不下来了~");
+}
+*/
+/*
+while(true){
+System.out.println("我停不下来了~");
+}
+*/
+do{
+System.out.println("我停不下来了~");
+}while(true);
+System.out.println("看看我能被执行吗?~"); // 无法访问的语句
+}
+}
+
+```
+
+#### 4.4跳转控制语句
+
+- 跳转控制语句（break）
+  
+  跳出循环，结束循环
+
+- 跳转控制语句（continue）
+
+- 跳过本次循环，继续下次循环
+
+- 注意：continue只能在循环中进行使用！
+  
+  ```java
+  public class Demo1Continue {
+  /*
+  continue : 跳过某次循环体内容的执行
+  注意：使用是基于条件控制, 在循环内部使用.
+  需求: 模拟电梯上行的过程 1-24层, 4层不停.
+  */
+  public static void main(String[] args){
+  for(int i = 1; i <= 24; i++){
+  if(i == 4){
+  continue;
+  }
+  System.out.println(i + "层到了~");
+  }
+  }
+  }
+  ```
+
+```java
+public class Demo2Break {
+/*
+break : 终止循环体内容的执行
+注意：使用是基于条件控制的
+break语句只能在循环和switch中进行使用.
+需求: 模拟20岁工作到80岁, 60岁退休.
+*/
+public static void main(String[] args){
+for(int i = 20; i <= 80; i++){
+if(i == 60){
+break; // 结束整个循环
+}
+System.out.println(i + "岁正在上班");
+}
+}
+}
+```
+
+```java
+import java.util.Scanner;
+public class Test {
+/*
+需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
+步骤:
+1. 不明确用户操作几次, 使用死循环包裹业务逻辑
+2. 匹配到0的时候，使用break结束循环死循环
+*/
+public static void main (String[] args){
+lo:while(true){
+System.out.println("请输入您要查看的星期数:");
+System.out.println("(如无需继续查看,请输入0退出程序)");
+// 1. 键盘录入星期数据，使用变量接收
+Scanner sc = new Scanner(System.in);
+int week = sc.nextInt();
+// 2. 多情况判断，采用switch语句实现
+switch(week){
+// 3. 在不同的case中，输出对应的减肥计划
+case 0:
+System.out.println("感谢您的使用");
+break lo;
+case 1:
+System.out.println("跑步");
+break;
+case 2:
+System.out.println("游泳");
+break;
+case 3:
+System.out.println("慢走");
+break;
+case 4:
+System.out.println("动感单车");
+break;
+case 5:
+System.out.println("拳击");
+break;
+case 6:
+System.out.println("爬山");
+break;
+case 7:
+System.out.println("好好吃一顿");
+break;
+default:
+System.out.println("您的输入有误");
+break;
+}
+}
+}
+}
+```
+
+## 5.Random
+
+#### 5.1Random产生随机数（掌握）
+
+- 概述：
+  
+  Random类似Scanner，也是java提供好的API，内部提供了产生随机数的功能
+  
+  API（java已经写好的代码）
+
+- 使用步骤：
+  1.导入包
+  
+  impor java.util.Random;
+  
+  2.创建对象
+  
+  Random r = new Random();
+  
+  3.产生随机数
+  
+  int num = r.nextInt(10)
+
+- 示例代码：
+
+```java
+import java.util.Random;
+public class Demo1Random {
+/*
+Random : 产生随机数
+1. 导包 : import java.util.Random;
+导包的动作必须出现在类定义的上面
+2. 创建对象 : Random r = new Random();
+上面这个格式里面，r 是变量名，可以变，其他的都不允许变
+3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包
+括0,不包括10
+上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不
+允许变
+需求: 产生随机数1-10之间的
+*/
+public static void main(String[] args){
+// 2. 创建对象
+Random r = new Random();
+for(int i = 1; i <= 10; i++){
+// 3. 获取随机数
+int num = r.nextInt(10) + 1; // 1-10
+System.out.println(num);
+}
+}
+}
+```
+
+5.2Random练习-猜数字（应用）
+
+- 需求：
+
+程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+
+当猜错的时候根据不同情况给出相应的提示
+
+A.如果猜的数字比真实数字大，提示你猜的数据大了
+
+B.如果猜的数字比真实数字小，提示你猜的
+
+C.如果猜的数字比真实数字相等，提示恭喜你猜中了
+
+- 示例代码
+
+```java
+import java.util.Scanner;
+import java.util.Random;
+public class Test {
+/*
+需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+当猜错的时候根据不同情况给出相应的提示
+如果猜的数字比真实数字大，提示你猜的数据大了
+如果猜的数字比真实数字小，提示你猜的数据小了
+如果猜的数字与真实数字相等，提示恭喜你猜中了
+1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+2. 使用Random产生一个1-100之间的数, 作为要猜的数
+3. 键盘录入用户猜的的数据
+4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死
+循环包裹
+6. 猜对之后, break结束.
+*/
+public static void main(String[] args){
+// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+Random r = new Random();
+Scanner sc = new Scanner(System.in);
+// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
+int randomNum = r.nextInt(100) + 1;
+// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用
+while(true)死循环包裹
+while(true){
+// 3. 键盘录入用户猜的的数据
+System.out.println("请输入您猜的数据:");
+int num = sc.nextInt();
+// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+if(num > randomNum){
+System.out.println("猜大了");
+}else if(num < randomNum){
+System.out.println("猜小了");
+}else{
+// 6. 猜对之后, break结束.
+System.out.println("恭喜,猜中了");
+break;
+}
+
+}
+
+S
+y
+s
+t
+e
+m
+.
+o
+u
+t
+.
+p
+r
+i
+n
+t
+l
+n
+(
+
+"
+感
+谢
+您
+的
+使
+用
+"
+);
+}
+}
+```
+
+汽车收费
+
+```java
+import java.util.Scanner;
+
+public class 分支结构Switch {
+    public static void main(String[] args) {
+        int num;
+       String cx ;
+       double ff ;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入车型：");
+         cx = sc .next();
+        System.out.println("请输入行车千米数：");
+        double lc = sc.nextDouble();
+         num = 0;
+        if(cx.equals("夏利")){
+            num=1;
+        } else
+            if (cx.equals("富康")) {
+            num= 2;
+        } else
+            if (cx.equals("桑塔纳")) {
+                num=3;
+            }else
+            {
+                System.out.println("输入错误");return;
+            }
+            switch (num){
+                case 1:if (lc<=3) ff=3;
+                else ff = 3+2.1*(lc-3);
+                    System.out.println("乘车费用为："+ff);
+                break;
+                case 2:if (lc<=3) ff=4;
+                else ff = 3+2.4*(lc-3);
+                    System.out.println("乘车费用为："+ff);
+                    break;
+                case 3:if (lc<=3) ff=5;
+                else ff = 3+2.7*(lc-3);
+                    System.out.println("乘车费用为："+ff);
+                    break;
+                default:
+                    System.out.println("请重新输入!");
+            }
+
+    }
+}
+
+```
+
+判断字符
+
+```java
+import java.util.Scanner;
+
+public class 判断字符Switch {
+    public static void main(String[] args) {
+        //小写声母
+        String[] ch1 = {"b", "p", "m", "f", "d", "t", "n", "l", "g", "k", "h", "j", "q", "x", "zh", "ch", "sh", "r", "z", "c", "s", "y", "w"};
+//大写声母
+        String[] ch11 = {"B", "P", "M", "F", "D", "T", "N", "L", "G", "K", "H", "J", "Q", "X", "ZH", "CH", "SH", "R", "Z", "C", "S", "Y", "W"};
+//小写韵母
+        String[] ch2 = {"a", " o", "e", " i", "u", "v"};
+//大写韵母
+        String[] ch22 = {"A", " O", "E", "I", "U", "V"};
+        Scanner sn = new Scanner(System.in);
+        while (true) {
+            System.out.println("请输入：");
+            String str = sn.next();
+            boolean isWord = false;
+            for (int i = 0; i < ch1.length; i++) {
+                if (str.equals(ch1[i])) {
+                    System.out.println("小写声母：" + str);
+                    isWord = true;
+                    break;
+                }
+            }
+            for (int i = 0; i < ch11.length; i++) {
+                if (str.equals(ch11[i])) {
+                    System.out.println("大写声母：" + str);
+                    isWord = true;
+                    break;
+                }
+            }
+            for (int i = 0; i < ch2.length; i++) {
+                if (str.equals(ch2[i])) {
+                    System.out.println("小写韵母：" + str);
+                    isWord = true;
+                    break;
+                }
+            }
+            for (int i = 0; i < ch22.length; i++) {
+                if (str.equals(ch22[i])) {
+                    System.out.println("大写韵母：" + str);
+                    isWord = true;
+                    break;
+                }
+            }
+            if (!isWord) {
+                System.out.println("不是字母" + str);
+            }
+        }
+    }
+}
+```
+
+判断今天是今年第几天
+
+```java
+import java.util.Scanner;
+
+public class 闰年Switch {
+    public static void main(String[] args) {
+        int years,month,day,sum = 0;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("\n请输入年.月.日:\n");
+        years = sc.nextInt();
+       month = sc.nextInt();
+        day= sc.nextInt();
+        switch  (month){
+            case 1:sum=0;break;
+            case 2:sum=31;break;
+            case 3:sum=59;break;
+            case 4:sum=90;break;
+            case 5:sum=120;break;
+            case 6:sum=151;break;
+            case 7:sum=181;break;
+            case 8:sum=212;break;
+            case 9:sum=243;break;
+            case 10:sum=273;break;
+            case 11:sum=304;break;
+            case 12:sum=334;break;
+            default:
+                System.out.println("date");break;
+        }
+            sum = sum+day;
+        if( years%4==0 && years%100!=0||years%400==0)
+        {if (month>=3)
+                sum++;
+            else
+                sum= sum+day;
+            
+        }
+
+        System.out.println("今天是今年的第"+sum);
+
+
+
+    }
+}
+
+```
+
+