diff --git "a/32 \351\202\223\347\220\252/20221202 switch\350\257\255\346\263\225.md" "b/32 \351\202\223\347\220\252/20221202 switch\350\257\255\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f93e3e66d07d63c2349fd130459ac556a6634d78
--- /dev/null
+++ "b/32 \351\202\223\347\220\252/20221202 switch\350\257\255\346\263\225.md"	
@@ -0,0 +1,81 @@
+## 1.switch语句
+
+#### 1.1分支语句switch语句
+
+- #####    格式
+
+
+~~~java
+switch (表达式) {
+	case 1:
+		语句体1;
+		break;
+	case 2:
+		语句体2;
+		break;
+	...
+	default:
+		语句体n+1;
+		break;
+}
+~~~
+
+- #####  执行流程：
+
+  -  首先计算出表达式的值
+
+  -  其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结束。
+
+  -  最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+## 1.2 switch案例-减肥计划
+
+- ##### 需求：键盘录入星期数，显示今天的减肥活动
+~~~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;
+		}
+	}
+}         
+~~~
\ No newline at end of file
diff --git "a/32 \351\202\223\347\220\252/20221202 \346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245\345\210\206\346\224\257\347\273\223\346\236\204\344\271\213if\350\257\255\345\217\245.md" "b/32 \351\202\223\347\220\252/20221202 \346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245\345\210\206\346\224\257\347\273\223\346\236\204\344\271\213if\350\257\255\345\217\245.md"
new file mode 100644
index 0000000000000000000000000000000000000000..086944ecf1bf7867e1d0c4e74304f97e669f766a
--- /dev/null
+++ "b/32 \351\202\223\347\220\252/20221202 \346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245\345\210\206\346\224\257\347\273\223\346\236\204\344\271\213if\350\257\255\345\217\245.md"	
@@ -0,0 +1,228 @@
+## 3. 流程控制语句
+
+在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
+
+### 3.1 流程控制语句分类(了解)
+
+​	顺序结构
+
+​	分支结构(if, switch)
+
+​	循环结构(for, while, do…while)
+
+### 3.2 顺序结构(了解)
+
+顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
+
+顺序结构执行流程图：
+
+![1545615769372](E:\教材\后端\2img\图片2.png)
+
+### 3.3 分支结构之if语句
+
+#### 3.3.1 if语句格式1（理解）
+
+~~~java
+格式：
+if (关系表达式) {
+    语句体;	
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体
+
+③如果关系表达式的值为false就不执行语句体
+
+④继续执行后面的语句内容
+
+![1545616039363](E:\教材\后端\2img\图片3.png)
+
+示例：
+
+~~~java
+public class IfDemo {
+	public static void main(String[] args) {
+		System.out.println("开始");
+        
+		// 如果年龄大于18岁, 就可以上网吧
+		int age = 17;
+		
+		if(age >= 18){
+			// int a = 10;
+			System.out.println("可以上网吧");
+		}
+			
+		System.out.println("结束");
+	}
+}
+~~~
+
+#### 3.3.2 if语句格式2（理解）
+
+~~~java
+格式：
+if (关系表达式) {
+    语句体1;	
+} else {
+    语句体2;	
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体1
+
+③如果关系表达式的值为false就执行语句体2
+
+④继续执行后面的语句内容
+
+![1545616221283](E:\教材\后端\2img\图片4.png)
+
+示例：奇偶数
+
+​	任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+~~~java
+public class Demo2If {
+	public static void main(String[] args) {
+		// 程序判断一个数, 是奇数还是偶数
+		int num = 9;
+		
+		if(num % 2 == 0){
+			System.out.println("偶数");
+		}else{
+			System.out.println("奇数");
+		}
+	}
+}
+~~~
+
+#### 3.3.3 if语句格式3（理解）
+
+~~~java
+格式：
+if (关系表达式1) {
+    语句体1;	
+} else if (关系表达式2) {
+    语句体2;	
+} 
+…
+else {
+    语句体n+1;
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式1的值
+
+②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+④…
+
+⑤如果没有任何关系表达式为true，就执行语句体n+1。
+
+![1545616667104](E:\教材\后端\2img\图片5.png)
+
+示例：
+
+​	定义一个在0~100之间的变量a, 90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油！
+
+~~~java
+public class Demo3If {
+	public static void main(String[] args){
+		int score = 65;
+		if(score >= 90 && score <= 100){
+			System.out   else if (score >= 80 && score <= 89){
+			System.out.println("良好");
+		}else if (score >= 70 && score <= 79){
+			System.out.println("中等");
+		}else if (score >= 60 && score <= 69){
+			System.out.println("及格");
+		}else if (score >= 0 && score <= 59){
+			System.out.println("请努力加油");
+		}else{
+			System.out.println("成绩有误!");
+		}
+	}
+}
+~~~
+
+#### 3.3.4 if语句格式3案例（应用）
+
+  
+
+​	①小明的考试成绩未知，可以使用键盘录入的方式获取值
+
+​	②由于奖励种类较多，属于多种判断，采用if...else...if格式实现
+
+​	③为每种判断设置对应的条件
+
+​	④为每种判断设置对应的奖励
+~~~java
+import java.util.Scanner;
+public class IfTest02 {
+	public static void main(String[] args){
+		// 1. 使用Scanner录入考试成绩
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入您的成绩:");
+		int score = sc.nextInt();
+		// 2. 判断成绩是否在合法范围内 0~100
+		if(score >=0 && score <= 100){
+			// 合法成绩
+			// 3. 在合法的语句块中判断成绩范围符合哪一个奖励
+			if(score >= 95 && score <= 100){
+				System.out.println("自行车一辆");
+			}else if(score >= 90 && score <= 94){
+				System.out.println("游乐场一次");
+			}else if(score >= 80 && score <= 89){
+				System.out.println("变形金刚一个");
+			}else {
+				System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
+			}
+		}else{
+			// 非法的话, 给出错误提示
+			System.out.println("您的成绩输入有误!");
+		}
+	}
+}
+~~~
+
+### 作业
+
+~~~java
+import java.util.Scanner;
+
+public class inquire {
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入查询的数据（如输入超过二及以上则查询第一位）");
+
+        char value = sc.next().charAt(0);
+        double va = (double) value;
+            System.out.println("输入~结束查询");
+            if (va <= 90 && va >= 65) {
+                System.out.println("您输入的为大写");
+                if (va == 65 | va == 79 | va == 69 | va == 73 | va == 85 | va == 86) {
+                    System.out.println("您输入的为韵母");
+                }
+            } else if (va <= 122 && va >= 97) {
+                System.out.println("您输入的为小写");
+                if (va == 97 | va == 111 | va == 101 | va == 105 | va == 117 | va == 118) {
+                    System.out.println("您输入的为韵母");
+                }
+            } else {
+                System.out.println("你输入的不是字母");
+            }
+    }
+}
+~~~
\ No newline at end of file
diff --git "a/32 \351\202\223\347\220\252/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md" "b/32 \351\202\223\347\220\252/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..502b81ed8f9ebca886cf282c9e738c79412984c2
--- /dev/null
+++ "b/32 \351\202\223\347\220\252/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md"	
@@ -0,0 +1,269 @@
+## 跳转循环
+
+- 跳转控制语句（break）：跳出循环，结束循环
+
+- 跳转控制语句（continue）：跳过本次循环，继续下次循环
+
+- 示例
+
+  ```java
+  public class S1 {
+  	/*
+  		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 + "岁正在上班");
+  		}
+  	}
+  }
+  
+  
+  public class S1 {
+  	/*
+  		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 + "层到了~");
+  		}
+  	}
+  }
+  ```
+
+## 随机数
+
+- 使用步骤
+
+  1. 导入Random包：import java.util.Random;
+
+  2. 创建对象：Random r = new Random();
+
+  3. 产生随机数：int num = r.nextInt(10);【10代表的时随机数的范围为0到9，即不包括所输入的数】
+
+  4. 示例
+
+     ```java
+     import java.util.Random;
+     public class S1 {
+     	/*
+     		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;
+  
+  //第二种格式：数据类型 数组名 []
+  //示例
+  int arr[];
+  double arr[];
+  char arr[];
+  ```
+
+- 数组的动态初始化
+
+  1. 定义：数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+  2. 格式
+
+     ```java
+     //数据类型[] 数组名 = new 数据类型[数组长度];
+     int[] arr = new int[3];
+     //等号左边{int:数组的数据类型、[]:代表这是一个数组、arr:代表数组的名称}
+     //等号右边{new:为数组开辟内存空间、int:数组的数据类型、[]:代表这是一个数组、3:代表数组的长度}
+     ```
+
+  3. 示例
+
+     ```java
+     package com.itheima.array;
+     public class S1 {
+         /*
+             数组的动态初始化:
+                             在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
+             动态初始化格式:
+                             数据类型[] 数组名 = 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. 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 
+
+     ```java
+     //格式
+     数组名[索引];
+     ```
+
+  2. 示例
+
+     ```java
+     package com.itheima.array;
+     public class Demo3ArrayIndex {
+         /*
+             数组动态初始化:
+                     初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
+             数组的元素访问格式:
+                     数组名[索引]
+                     索引: 数组中数据的编号方式, 编号从0开始
+                     作用: 访问数组容器中的空间位置
+             注意:
+                     数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
+          */
+         public static void main(String[] args) {
+             int[] arr = new int[3];         // 0 1 2
+             System.out.println(arr);        // 数组的内存地址  [I@10f87f48
+             // 数组名[索引]  访问数组容器中的空间位置
+             System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
+             System.out.println(arr[1]);
+             System.out.println(arr[2]);
+             System.out.println("--------------");
+             // 数组名[索引]
+             arr[0] = 11;
+             arr[1] = 22;
+             arr[2] = 33;
+             System.out.println(arr[0]);
+             System.out.println(arr[1]);
+             System.out.println(arr[2]);
+         }
+     }
+     ```
+
+## 作业
+
+1. 猜大小
+
+   ```java
+   import java.util.Random;
+   import java.util.Scanner;
+   public class 猜大小 {
+       public static void main(String[] args) {
+           Random ran = new Random();
+           Scanner sc = new Scanner(System.in);
+           Scanner tb = new Scanner(System.in);
+           int rnum =ran.nextInt(90)+10;
+           int cishu = 0;
+           while(true){
+               System.out.println("请输入您所猜的数：");
+               int snum = sc.nextInt();
+               if (snum > rnum){
+                   System.out.println("猜大了！");
+                   cishu++;
+               }else if (snum < rnum){
+                   System.out.println("猜小了！");
+                   cishu++;
+               }else{
+                   System.out.println("恭喜您，猜对了！");
+                   cishu++;
+                   break;
+               }
+               if (cishu == 3){
+                   System.out.println("您已经猜错三次，请问是否投币继续（是Y/否N）");
+                   char sftb = tb.next().charAt(0);
+                   if (sftb == 89) {
+                       System.out.println("感谢您的投币，请继续！");
+                   }else if(sftb == 78){
+                       System.out.println("感谢您的参与，欢迎下次再来！");
+                       break;
+                   }else{
+                       System.out.println("输入出错，请下次再来！");
+                       break;
+                   }
+               }
+           }
+           System.out.println("您一共猜了" + cishu + "次");
+       }
+   }
+   ```
+
+2. 数组
+
+   ```java
+   import java.util.Arrays;
+   import java.util.Random;
+   public class x {
+       public static void main(String[] args) {
+           Random r = new Random();
+           int[] arr = new int[10];
+           for (int i = 0;i<arr.length;i++){
+               arr[i] = r.nextInt(41)+10;
+           }
+           System.out.println("打乱前："+Arrays.toString(arr));
+           for (int i = 0; i<arr.length;i++){
+               int a = r.nextInt(arr.length);
+               int b = r.nextInt(arr.length);
+               int t = arr[a];
+               arr[a] = arr[b];
+               arr[b] = t;
+           }
+           System.out.println("打乱后："+Arrays.toString(arr));
+           int max = arr[0];
+           for (int i = 1; i<arr.length;i++){
+               if (arr[i]>max){
+                   max = arr[i];
+               }
+           }
+           System.out.println("最大值为："+max);
+       }
+   }
+   ```
+
+   
\ No newline at end of file
diff --git "a/32 \351\202\223\347\220\252/20221306\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md" "b/32 \351\202\223\347\220\252/20221306\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..df2c9266252b0262565aa448135d6b47c2ed4b5a
--- /dev/null
+++ "b/32 \351\202\223\347\220\252/20221306\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md"	
@@ -0,0 +1,152 @@
+## for循环
+
+- 格式
+
+  ```java
+  for (初始化语句;条件判断语句;条件控制语句){
+  	循环语句体;
+  }
+  //初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+  //条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+  //循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+  //条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出1-5和5-1的数据
+  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);
+  		}
+  	}
+  }
+  
+  //需求：输出1-100之间的偶数和
+  public class ForTest01 {
+  	public static void main(String[] args) {
+          int num = 0;  //定义变量接收数据和
+          for(int i = 1; i <= 100; i++){   //循环
+              if(i % 2 == 0){              //if语句判断是否为偶数
+                  num += i;                //是偶数就加起来
+              }
+          }
+          System.out.print("1-100之间的偶数和为：" + num);  //输出值
+      }
+  }
+  
+  //需求：输出所有的水仙花数，每行输出两个
+  public class S1 {
+      public static void main(String[] args) {
+          int a = 0;  //接收水仙花数输出次数
+          for (int i = 100; i <= 1000; i++){
+              int ge = i % 10;            //求出个位上的值
+              int shi = i / 10 % 10;      //求出十位上的值
+              int bai = i / 100 % 10;     //求出百位上的值
+              if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
+                  System.out.print(i + " ");  //输出水仙花数
+                  a++;                        //每输出一次a+1
+                  if (a % 2 == 0){            //每当输出两次就换行
+                      System.out.println();
+                  }
+              }
+          }
+      }
+  }
+  ```
+
+- 注意：
+
+  println：是输出后换行
+
+  print：输出后不换行
+
+## while循环
+
+- 格式
+
+  ```java
+  初始化语句;
+  while (条件判断语句){
+      循环语句体;
+      条件控制语句;
+  }
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出5次"HelloWorld"
+  public class WhileDemo {
+  	public static void main(String[] args) {
+  	//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++;
+  		}
+  	}
+  }
+  
+  //需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
+  public class S1 {
+      public static void main(String[] args) {
+          int ci = 0; //定义计数器，计算折叠几次，初始值为0
+          double zhi = 0.1;  //定义纸张厚度
+          int shan = 8844430;  //定义珠穆朗玛峰高度
+          while (shan >= zhi){
+              zhi *= 2;
+              ci++;
+          }
+          System.out.println("纸张需要折" + ci + "次才能和珠穆朗玛峰一样高");
+      }
+  }
+  ```
+
+## do...while循环
+
+- 格式
+
+  ```java
+  初始化语句;
+  do {
+      循环语句体;
+      条件控制语句;
+  }while(条件判断语句);
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出5次"HelloWorld"
+  public class DoWhileDemo {
+  	public static void main(String[] args) {
+  		//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);
+  	}
+  }
+  ```
+
+  
\ No newline at end of file