diff --git "a/05 \346\236\227\344\274\237\345\275\254/20221202 \345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\345\272\224\347\224\250.md" "b/05 \346\236\227\344\274\237\345\275\254/20221202 \345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\345\272\224\347\224\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..405b7071c504fe8ba15d29da30a01644c9d5c5a4
--- /dev/null
+++ "b/05 \346\236\227\344\274\237\345\275\254/20221202 \345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\345\272\224\347\224\250.md"	
@@ -0,0 +1,371 @@
+# 分支结构的应用
+
+- [x] #### 一、if条件结构
+
+- [x] #### 二、多重if语句
+
+- [x] #### 三、嵌套if语句
+
+- [x] #### 四、switch结构
+
+
+
+**一、**块作用域
+
+```java
+public class 第四单元 {
+    public static void main(String[] args) {
+        {
+          int bkp=23;
+            System.out.println(bkp);
+        }
+        int bkp =22;
+        System.out.println(bkp);
+    }
+
+}
+```
+
+### 一、分支结构之if-else
+
+##### if-else 语句
+
+if-else 结构根据一个布尔值的真假来悬着做不同的事情，即”如果······否则······“。早在第三单元的时候我们就学习过类似的程序逻辑了，那就是条件运算符（三元运算符）。其实if-else只不过是条件运算符的完整写法而已。
+
+1. 例如：你是老板，你想有一个程序能够帮你计算员工的周薪，员工的周工时(hours)如果低于40，每小时薪水为rate，如果员工由于加班，周工时超过了 40个小时，超过 40个小时的部分按照 1.5 倍时薪计算。
+
+这个时候我们就可以用if-else来计算
+
+```java
+import java.util.Scanner;
+
+public class 分支结构IFelse {
+    public static void main(String[] args) {
+        double pay ;//周薪
+        int hours;//周工时
+        int rate = 55;//每小时薪水
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入这个员工的周工作小时：");
+        hours=sc.nextInt();
+        if (hours<40){
+            pay = hours * rate;
+        }
+        else {
+            pay=(40*rate+((hours-40)*1.5*rate));
+        }
+        System.out.println("该员工上周工资为："+pay);
+    }
+}
+```
+
+
+
+## 二、多重if语句
+
+1. 某些情况下，需要对一系列对等的条件进行判断，从而决定采用什么样的解决办法例如，对于学员的成绩来说，不同的分数对应不同的等级。对于这类问题来说，使用之前讲述的 if语句很难解决，或写法不简洁，可读性较差，但使用多重 if语句将能很好地解决多重 if语句的语法如下:
+
+```java
+	if (表达式1){
+        语句1
+    } else if（表达式2）{
+        语句2
+    }else if（表达式3）{
+        语句3
+    }else if(表达式4){
+    	语句41
+    }else if(表达式5){
+        语句5
+    }else{        //此处的表达式如果是代表所有的可不写
+        语句6
+    }
+
+```
+
+
+
+1. 例题：假如学员的考试等级依据考试成绩来判断，规则为:成绩大于等于 90 分等级为 A，成绩大于等于 80 分小于 90 分等级为 B，成绩大于等于 70 分小于 80 分输出 C，成绩大于等于60分和小于 70分等级为 D，成绩小于 60 分输出E。下面程序首先要求学员输入成绩然后输出对应的等级。
+
+```java
+import java.util.Scanner;
+
+public class 多重if语句 {
+    public static void main(String[] args) {
+        int score; //分数
+        char garde; //等级
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入你的分数:");
+        score=sc.nextInt();
+        if (score>=90){
+            garde='A';
+        } else if (score>=80) {
+            garde='B';
+        } else if (score>=70) {
+            garde='C';
+        } else if (score>=60) {
+            garde='D';
+        }else{
+            garde='E';
+        }
+        System.out.println("分数为 : "+score);
+        System.out.println("等级为 : "+garde);
+    }
+}
+
+```
+
+### 三、嵌套if语句
+
+嵌套if语句可以在条件内，针对真或假的情况，在制定条件进行判断，从而拥有执行更多语句的功能。嵌套if语句。
+
+```java
+public class TriangleDemo {
+    public static viod main(String[] args){
+        int a = 1
+        int b = 2    
+    	int c = 3
+        if(a>0&&b>0&&c>0){
+            if(a+b>c&&a+c>b&&b+c>a){
+                System.out.println("这三个数能组成三角形！");
+            }else{
+                System.out.println("这三个数字不能组成三角形！");
+            }
+        }else{
+            System.out.println("三角形的三条边必须是正数！");
+        }
+    }
+}
+```
+
+## 分支结构之switch
+
+格式
+
+```java
+switch (表达式) {
+	case 1:
+		语句体1;
+		break;
+	case 2:
+		语句体2;
+		break;
+	...
+	default:
+		语句体n+1;
+		break;
+}
+```
+
+- 执行流程：
+
+  - 首先计算出表达式的值
+  - 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
+  - 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+  
+
+####  switch案例-减肥计划
+
+##### 需求：键盘录入星期数，显示今天的减肥活动
+
+周一：跑步
+周二：游泳
+周三：慢走
+周四：动感单车
+周五：拳击
+周六：爬山
+周日：好好吃一顿
+
+```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.练习5：使用switch 和计语句解决出租车车费问题
+
+##### 【问题描述】
+
+某市不同车牌的出租车3千米的起步价和计费分別为：夏利3元，3千米以外。2.1元/千米;
+富康4元，3千米以外，2.4元/千米：桑塔纳5元，3千米以外，2.7元/千米，编程实现从键盘
+输入乘车的车型及行车千米数，输出应付车费。
+
+##### 【问题分析】
+
+首先需要确定乘客坐的是什么类型的出租车，可以使用1~3分別表示三种车型。
+输入车型后，使用switch 语句进行判断，在每一个case内部，根据用乘坐的千米数，使
+用正if语句判断是否超过起步距高，从而计算出应付车费。
+
+
+
+```java
+import java.util.Scanner;
+
+public class switc和if语句出租车 {
+    public static void main(String[] args) {
+        //1;夏利
+        //2;富康
+        //3;桑塔纳
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入您需要的车型");
+        int type = sc.nextInt();
+        System.out.println("请输入您出行的千米数");
+        double how = sc.nextDouble();
+        switch (type) {
+            case 1 :
+                if (how > 3) {
+                    System.out.println("应付的费用是：" + (3 + (how - 3) * 2.1) + "元");
+                } else {
+                    System.out.println("应付的费用是：" + (3) + "元");
+                }
+                break;
+            case 2:
+                if (how > 3) {
+                    System.out.println("应付的费用是：" + (4 + (how - 3) * 2.4) + "元");
+                } else {
+                    System.out.println("应付的费用是：" + (4) + "元");
+                }
+                break;
+            case 3:
+                if (how>3){
+                    System.out.println("应付的费用是：" + (5 + (how - 3) * 2.7) + "元");
+                }else {
+                    System.out.println("应付的费用是："+(6)+"元");
+                }
+                break;
+            default:
+                System.out.println("您输入的车型错误");
+                break;
+        }
+    }
+}
+```
+
+### 2.第二题
+
+##### 【拓展作业】
+
+使用switch 和if语句算出今天是今年的第几天(提示：以3月3日为例，应该先把
+前两个月的天数加起来，然后再加上3 天即为本年的第几天：需要考虑闰年的情况，如果
+输入的年份是闰年且输入的月份大于或等手 3，需要多加 1天)。
+
+```java
+package nian;
+
+import java.util.Scanner;
+
+public class switchyuif {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入年份：");
+        int year = sc.nextInt();
+        if (year<=0){
+            System.out.println("输入的年份有误");
+        }else {
+            System.out.println("请输入月份：");
+            int month = sc.nextInt();
+            if (!(month>=1 && month<=12)){
+                System.out.println("输入的月份有误");
+            }else{
+                System.out.println("请输入日数：");
+                int day = sc.nextInt();
+                if (!(day>=1 && day<=31)){
+                    System.out.println("输入的日数误");
+                }else {
+                    int sum=0;
+                    switch (month){
+                        case 12 :sum += 30;
+                        case 11: sum += 31;
+                        case 10: sum += 30;
+                        case 9: sum += 31;
+                        case 8: sum += 31;
+                        case 7: sum += 30;
+                        case 6: sum += 31;
+                        case 5: sum += 30;
+                        case 4: sum += 31;
+                        case 3:
+                            if (year%4==0 && year%100!=0 || year%400==0){
+                                sum += 29;
+                            }else {
+                                sum += 28;
+                            }
+                        case 2: sum += 31;
+                        case 1: sum += day;
+                    }
+                    System.out.println(year+"年"+month+"月"+day+"日是今年的第"+sum+"天");
+                }
+            }
+        }
+    }
+}
+```
+
+### 3.第三题
+
+编写一个程序，根据用户输入的一个字符，判断该字符是不是字母，如果是字母，
+判断该字母是声母还是韵母，是大写字母还是小写字母：如果不是字母，则输出“你输入
+的字符不是字母”
+
+```java
+import java.util.Scanner;
+
+public class panduanyunmu {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入一个字符");
+        char act = sc.next().charAt(0);
+        if (act>=65 && act<=90 ||  act>=97 && act<=122){
+            switch (act){
+                case 'a': case 'A': case 'e': case 'E':
+                case 'i': case 'I': case 'o': case'O':
+                case 'u': case 'U':
+                    System.out.println(act+"是韵母");
+                    break;
+                default:
+                    System.out.println(act+"是声母");
+            }
+            if (act>=65 || act<=90){
+                System.out.println(act+"是大写字母");
+            }else{
+                System.out.println(act+"是小写字母");
+            }
+        }else {
+            System.out.println("你输入的字符不是字母");
+        }
+    }
+}
+```
+
diff --git "a/05 \346\236\227\344\274\237\345\275\254/20221206 for.while.do\345\276\252\347\216\257.md" "b/05 \346\236\227\344\274\237\345\275\254/20221206 for.while.do\345\276\252\347\216\257.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2f9c1900e44008a1c354f6fe6686dda870a79406
--- /dev/null
+++ "b/05 \346\236\227\344\274\237\345\275\254/20221206 for.while.do\345\276\252\347\216\257.md"	
@@ -0,0 +1,254 @@
+
+
+
+
+# for循环
+
+#### 循环语句-for循环
+
+```java
+for (初始化语句;条件判断语句;条件控制语句) {
+	循环体语句;
+}
+```
+
+- ①执行初始化语句
+- ②执行条件判断语句，看其结果是true还是false 如果是false，循环结束 如果是true，继续执行 
+- ③执行循环体语句 
+- ④执行条件控制语句 
+- ⑤回到
+- ②继续
+
+
+
+####  for循环案例-输出数据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);
+		}
+	}
+}
+```
+
+
+
+#### for循环案例-求1-5数据和
+
+需求：求1-5之间的数据和，并把求和结果在控制台输出
+示例代码：
+
+```java
+public class ForTest02 {
+	public static void main(String[] args) {
+		int sum =0
+        for(int i=1;i<=5;i++){
+            sum+=i
+        }
+        System.out.println("1-5之间的数据和是"+sum);
+    }
+```
+
+#### for循环案例-求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);
+	}
+}    
+```
+
+#### 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);
+			}
+		}
+	}
+}
+```
+
+#### for循环案例-每行打印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;
+i			nt 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();
+			}
+		}
+	}
+}
+}
+```
+
+# while循环
+
+#### 循环语句-wihle
+
+while循环完整格式：
+
+```java
+初始化语句;
+while (条件判断语句) {
+	循环体语句;
+	条件控制语句;
+}
+```
+
+while循环执行流程：
+①执行初始化语句
+②执行条件判断语句，看其结果是true还是false
+			如果是false，循环结束
+
+​			如果是true，继续执行
+
+③执行循环体语句
+④执行条件控制语句
+⑤回到②
+
+实列代码：
+
+```java
+public class whieDemo{
+    public static void main(String[] args)
+	//需求：在控制太输出5次"Helloworld"
+    //for循环实现
+    for(int i=1; i<=5; i++){
+        	System.out.prinrln("Helloworld")
+    }
+    System.out.println("---------");
+    //while循环实现
+    int j = 1;
+    while(j<=5){
+        System.out,println("HelloWorld");
+        j++
+    }
+}
+```
+
+#### while循环案例-珠穆朗玛峰
+
+需求：世界最高山峰是珠穆朗玛峰(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 + "次");
+	}
+}
+```
+
+## 循环语句-dowhile循环
+
+完整格式：
+
+```java
+for死循环格式 :
+for(;;){
+    
+}
+
+while死循环格式 :
+
+while(true){
+    
+}
+
+do..while死循环格式 :
+
+do{
+    
+}while(true);
+```
+
diff --git "a/05 \346\236\227\344\274\237\345\275\254/20221208.\351\232\217\346\234\272\346\225\260..\346\225\260\347\273\204.md" "b/05 \346\236\227\344\274\237\345\275\254/20221208.\351\232\217\346\234\272\346\225\260..\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..393d055e5b4db02a53f1bd8b6c549caf831f7d1d
--- /dev/null
+++ "b/05 \346\236\227\344\274\237\345\275\254/20221208.\351\232\217\346\234\272\346\225\260..\346\225\260\347\273\204.md"	
@@ -0,0 +1,227 @@
+###  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 RandomDemo {
+	public static void main(String[] args) {
+		//创建对象
+		Random r = new Random();
+
+		//用循环获取10个随机数
+		for(int i=0; i<10; i++) {
+			//获取随机数
+			int number = r.nextInt(10);
+			System.out.println("number:" + number);
+		}
+
+		//需求：获取一个1-100之间的随机数
+		int x = r.nextInt(100) + 1;
+		System.out.println(x);
+	}
+}
+```
+
+#### Random练习-猜数字 
+
+ 需求： 程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？ 当猜错的时候根据不同情况给出相应的提示 A. 如果猜的数字比真实数字大，提示你猜的数据大了 B. 如果猜的数字比真实数字小，提示你猜的数据小了 C. 如果猜的数字与真实数字相等，提示恭喜你猜中了  示例代码：
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class RandomTest {
+	public static void main(String[] args) {
+		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
+		Random r = new Random();
+		int number = r.nextInt(100) + 1;
+
+		while(true) {
+			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
+			Scanner sc = new Scanner(System.in);
+
+			System.out.println("请输入你要猜的数字：");
+			int guessNumber = sc.nextInt();
+
+			//比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
+			if(guessNumber > number) {
+				System.out.println("你猜的数字" + guessNumber + "大了");
+			} else if(guessNumber < number) {
+				System.out.println("你猜的数字" + guessNumber + "小了");
+			} else {
+				System.out.println("恭喜你猜中了");
+				break;
+			}
+		}
+	}
+}
+
+```
+
+# 数组
+
+1. #### 数据类型 数组名[]
+
+```java
+int arr[];
+double arr[];
+char arr[];
+
+//动态初始化格式
+//数据类型[] 数组名 = new 数据类型[数组长度];
+int[] arr = new int[3];
+```
+
+- 等号左边：
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - arr:代表数组的名称
+- 等号右边：
+  - new:为数组开辟内存空间
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - 3:代表数组的长度
+
+
+
+#### 数组元素访问 
+
+### 1 什么是索引 
+
+ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。 
+ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 
+2.访问数组元素格式 
+数组名[索引];
+
+### 示例代码 
+
+```
+ public class ArrayDemo {
+       public static void main(String[] args) {
+           int[] arr = new int[3];
+
+​    //输出数组名
+​    System.out.println(arr); 
+
+​    //输出数组中的元素
+​    System.out.println(arr[0]);
+​    System.out.println(arr[1]);
+​    System.out.println(arr[2]);
+	}
+
+}
+```
+
+### 内存分配 
+
+13.5.1 内存概述 
+ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。 
+
+ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。 
+
+ 必须放进内存中才能运行，运行完毕后会清空内存。 
+
+ Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。 
+
+### java中的内存分配 
+
+目前我们只需要记住两个内存，分别是：
+
+| 区域名称   | 作用                                                       |
+| ---------- | ---------------------------------------------------------- |
+| 寄存器     | 给CPU使用，和我们开发无关。                                |
+| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。          |
+| 方法区     | 存储可以运行的class文件。                                  |
+| 堆内存     | 存储对象或者数组，new来创建的，都存储在堆内存。            |
+| 方法栈     | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
+
+## 单个数组的内存图
+
+![数组](img\数组.png)
+
+## 多个数组的内存图
+
+![数组1](img\数组1.png)
+
+## 多个数组指向相同内存图
+
+![数组3](img\数组3.png)
+
+# 作业
+
+猜数字
+
+```java
+package 随机数;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class D3 {
+    public static void main(String[] args) {
+        Random r=new Random();
+        Scanner sc=new Scanner(System.in);
+        int randomNum = r.nextInt(100)+1;
+        while(true){
+            System.out.println("请输入您猜的数据：");
+            int sum = sc.nextInt();
+            if (sum>randomNum){
+                System.out.println("猜大了");
+            }else if (sum<randomNum){
+                System.out.println("猜小了");
+            }else {
+                System.out.println("恭喜你，猜中了");
+                break;
+            }
+        }
+    }
+}
+
+```
+
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class D4 {
+    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);
+    }
+}
+```
+
diff --git "a/05 \346\236\227\344\274\237\345\275\254/20221209 \346\225\260\347\273\204\345\210\235\345\247\213\345\214\226\357\274\214\351\225\277\345\272\246.md" "b/05 \346\236\227\344\274\237\345\275\254/20221209 \346\225\260\347\273\204\345\210\235\345\247\213\345\214\226\357\274\214\351\225\277\345\272\246.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b9ade36e665528aaa7df49acf3fbe23a793f4b52
--- /dev/null
+++ "b/05 \346\236\227\344\274\237\345\275\254/20221209 \346\225\260\347\273\204\345\210\235\345\247\213\345\214\226\357\274\214\351\225\277\345\272\246.md"	
@@ -0,0 +1,591 @@
+##  1.数组
+
+### 1.1 数组介绍
+
+​	数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。 
+
+### 1.2 数组的定义格式
+
+#### 1.2.1 第一种格式
+
+​	数据类型[] 数组名
+
+​	示例：
+
+```java
+int[] arr;        
+double[] arr;      
+char[] arr;
+```
+
+#### 1.2.2 第二种格式
+
+​	数据类型 数组名[]
+
+​	示例：
+
+```java
+int arr[];
+double arr[];
+char arr[];
+```
+
+### 1.3 数组的动态初始化
+
+#### 1.3.1 什么是动态初始化
+
+​	数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+#### 1.3.2 动态初始化格式
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度];
+```
+
+```java
+int[] arr = new int[3];
+```
+
+#### 1.3.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.4 数组元素访问
+
+#### 1.4.1 什么是索引
+
+​	每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+​	这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 	
+
+#### 1.4.2访问数组元素格式
+
+```java
+数组名[索引];
+```
+
+#### 1.4.3示例代码
+
+```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.5 内存分配
+
+#### 1.5.1 内存概述
+
+​	内存是计算机中的重要原件，临时存储区域，作用是运行程序。
+
+​	我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
+
+​	必须放进内存中才能运行，运行完毕后会清空内存。 
+
+​	Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。 
+
+#### 1.5.2 java中的内存分配
+
+- 目前我们只需要记住两个内存，分别是：栈内存和堆内存
+
+| 区域名称   | 作用                                                       |
+| ---------- | ---------------------------------------------------------- |
+| 寄存器     | 给CPU使用，和我们开发无关。                                |
+| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。          |
+| 方法区     | 存储可以运行的class文件。                                  |
+| 堆内存     | 存储对象或者数组，new来创建的，都存储在堆内存。            |
+| 方法栈     | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
+
+### 1.6 Java内存分配-一个数组内存图
+
+![1591007817165](F:\java 专业课资料\java\day\4img\1591007817165.png)
+
+### 1.7 两个数组内存图
+
+![1591007925899](F:\java 专业课资料\java\day\4img\1591007925899.png)
+
+### 1.8 多个数组指向相同内存图
+
+![1591007957052](F:\java 专业课资料\java\day\4img\1591007957052.png)
+
+### 1.9 数组的静态初始化
+
+#### 1.9.1 什么是静态初始化
+
+​	在创建数组时，直接将元素确定	
+
+#### 1.9.2 静态初始化格式
+
+- 完整版格式
+
+  ```java
+  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+  ```
+
+- 简化版格式
+
+  ```java
+  数据类型[] 数组名 = {元素1,元素2,...};
+  ```
+
+#### 1.9.3示例代码
+
+```java
+package com.itheima.array2;
+
+public class Demo1Array {
+    /*
+        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
+
+        完整格式:
+                    数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+        简化格式:
+                    数据类型[] 数组名 = {数据1,数据2,数据3...};
+     */
+    public static void main(String[] args) {
+        // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+        int[] arr = new int[]{11,22,33};
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+
+        // 数据类型[] 数组名 = {数据1,数据2,数据3...};
+        int[] arr2 = {44,55,66};
+        System.out.println(arr2);
+        System.out.println(arr2[0]);
+        System.out.println(arr2[1]);
+        System.out.println(arr2[2]);
+
+    }
+}
+```
+
+### 1.10 数组操作的两个常见问题
+
+#### 1.10.1 索引越界异常
+
+- 出现原因
+
+  ```java
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+          System.out.println(arr[3]);
+      }
+  }
+  ```
+
+  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+
+  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。 
+
+- 解决方案
+
+  将错误的索引修改为正确的索引范围即可！
+
+#### 1.10.2 空指针异常
+
+- 出现原因
+
+  ```java
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+  
+          //把null赋值给数组
+          arr = null;
+          System.out.println(arr[0]);
+      }
+  }
+  ```
+
+  arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+- 解决方案
+
+  给数组一个真正的堆内存空间引用即可！
+
+### 1.11 数组遍历
+
+- 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+
+  ```java
+  public class ArrayTest01 {
+  	public static void main(String[] args) {
+  		int[] arr = { 1, 2, 3, 4, 5 };
+  		System.out.println(arr[0]);
+  		System.out.println(arr[1]);
+  		System.out.println(arr[2]);
+  		System.out.println(arr[3]);
+  		System.out.println(arr[4]);
+  	}
+  }
+  ```
+
+   以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。 
+
+  ```java
+  public class ArrayTest01 {
+      public static void main(String[] args) {
+          //定义数组
+          int[] arr = {11, 22, 33, 44, 55};
+  
+          //使用通用的遍历格式
+          for(int x=0; x<arr.length; x++) {
+              System.out.println(arr[x]);
+          }
+      }
+  }
+  ```
+
+### 1.12 数组获取最大值
+
+- 最大值获取：从数组的所有元素中找出最大值。
+
+- 实现思路：
+
+  - 定义变量，保存数组0索引上的元素
+  - 遍历数组，获取出数组中的每个元素
+  - 将遍历到的元素和保存数组0索引上值的变量进行比较
+  - 如果数组元素的值大于了变量的值，变量记录住新的值
+  - 数组循环遍历结束，变量保存的就是数组中的最大值 
+
+- 代码实现：
+
+  ```java
+  package com.itheima.test;
+  
+  import java.util.Scanner;
+  
+  public class Test2Array {
+      /*
+          需求: 从数组中查找最大值
+  
+                  int[] arr = {12,45,98,73,60};
+  
+          实现步骤:
+                  1. 假设数组中的第一个元素为最大值
+                  2. 遍历数组, 获取每一个元素, 准备进行比较
+                  3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
+                  4. 循环结束后, 打印最大值.
+       */
+      public static void main(String[] args) {
+          int[] arr = {12,45,98,73,60};
+          // 1. 假设数组中的第一个元素为最大值
+          int max = arr[0];
+          // 2. 遍历数组, 获取每一个元素, 准备进行比较
+          for(int i = 1; i < arr.length; i++){
+              // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
+              if(arr[i] > max){
+                  max = arr[i];
+              }
+          }
+          //  4. 循环结束后, 打印最大值.
+          System.out.println("max:" + max);
+      }
+  }
+  
+  ```
+
+### 1.13 数组元素求和
+
+- 需求：键盘录入5个整数，存储到数组中，并对数组求和
+
+- 思路：
+      1.创建键盘录入对象，准备键盘录入
+      2.定义一个求和变量，准备记录累加后的结果
+      3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+      4.将键盘录入的数值存储到数组中
+      5.遍历数组，取出每一个元素，并求和
+      6.输出总和
+
+- 代码实现：
+
+  ```java
+  package com.itheima.test;
+  
+  import java.util.Scanner;
+  
+  public class Test3Array {
+      /*
+          需求：键盘录入5个整数，存储到数组中，并对数组求和
+  
+          思路：
+              1.创建键盘录入对象，准备键盘录入
+              2.定义一个求和变量，准备记录累加后的结果
+              3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+              4.将键盘录入的数值存储到数组中
+              5.遍历数组，取出每一个元素，并求和
+              6.输出总和
+       */
+      public static void main(String[] args) {
+          // 1.创建键盘录入对象，准备键盘录入
+          Scanner sc = new Scanner(System.in);
+          // 2.定义一个求和变量，准备记录累加后的结果
+          int sum = 0;
+          // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+          int[] arr = new int[5];
+          // 4.将键盘录入的数值存储到数组中
+          for(int i = 0; i < arr.length; i++){
+              System.out.println("请输入第" + (i+1) + "个整数:");
+              //arr[i] = 10;
+              arr[i] = sc.nextInt();
+          }
+  
+          // 5.遍历数组，取出每一个元素，并求和
+          for (int i = 0; i < arr.length; i++) {
+              sum += arr[i];
+          }
+  
+          // 6.输出总和
+          System.out.println("sum:" + sum);
+  
+      }
+  }
+  
+  ```
+
+### 1.14 数组基本查找【应用】
+
+- 需求：
+      已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
+      制台输出找到的索引值。
+
+- 思路：
+      1.定义一个数组，用静态初始化完成数组元素的初始化
+      2.键盘录入要查找的数据，用一个变量接收
+      3.定义一个索引变量，初始值为-1
+      4.遍历数组，获取到数组中的每一个元素
+      5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
+      6.输出索引变量
+
+- 代码实现：
+
+  ```java
+  public static void main(String[] args) {
+          // 1.定义一个数组，用静态初始化完成数组元素的初始化
+          int[] arr = {19, 28, 37, 46, 50};
+          // 2.键盘录入要查找的数据，用一个变量接收
+          Scanner sc = new Scanner(System.in);
+          System.out.println("请输入您要查找的元素:");
+          int num = sc.nextInt();
+          // 3.定义一个索引变量，初始值为-1
+          // 假设要查找的数据, 在数组中就是不存在的
+          int index = -1;
+          // 4.遍历数组，获取到数组中的每一个元素
+          for (int i = 0; i < arr.length; i++) {
+              // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
+              if(num == arr[i]){
+                  // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
+                  index = i;
+                  break;
+              }
+          }
+          //  6.输出索引变量
+          System.out.println(index);
+      }
+  }
+  
+  ```
+
+### 1.15 评委打分【应用】
+
+- 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
+                选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
+
+- 思路：
+      1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
+      2.键盘录入评委分数
+      3.由于是6个评委打分，所以，接收评委分数的操作，用循环
+      4.求出数组最大值
+      5.求出数组最小值
+      6.求出数组总和
+      7.按照计算规则进行计算得到平均分
+      8.输出平均分
+
+- 代码实现：
+
+  ```java
+      public static void main(String[] args) {
+          // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
+          int[] arr = new int[6];
+          // 2.键盘录入评委分数
+          Scanner sc = new Scanner(System.in);
+          //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
+          for (int i = 0; i < arr.length; i++) {
+              System.out.println("请输入第" + (i+1) + "个评委的打分:");
+              int score = sc.nextInt();
+              if(score >= 0 && score <= 100){
+                  // 合法的分值
+                  arr[i] = score;
+              }else{
+                  // 非法的分值
+                  System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
+                  i--;
+              }
+          }
+  
+          // 4.求出数组最大值
+          int max = arr[0];
+          for (int i = 1; i < arr.length; i++) {
+              if(max < arr[i]){
+                  max = arr[i];
+              }
+          }
+  
+          // 5.求出数组最小值
+          int min = arr[0];
+          for (int i = 1; i < arr.length; i++) {
+              if(min > arr[i]){
+                  min = arr[i];
+              }
+          }
+  
+          // 6.求出数组总和
+          int sum = 0;
+          for (int i = 0; i < arr.length; i++) {
+              sum += arr[i];
+          }
+  
+          // 7.按照计算规则进行计算得到平均分
+          int avg = (sum - max - min ) / 4;
+  
+          // 8.输出平均分
+          System.out.println(avg);
+      }
+  }
+  ```
+
+# 作业
+
+1. 闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】
+
+```java
+package 数组;
+
+import java.util.Random;
+
+public class D2 {
+    public static void main(String[] args) {
+        Random random = new Random();
+        //初始化长度为10的数组
+        int[] arr = new int[10];
+        System.out.print("随机的十个数为：");
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = random.nextInt(100);//[0,99)
+            System.out.print(" "+arr[i]);
+        }
+        
+        int max = arr[0], min = arr[0], sum = 0, ave = 0;
+        //便利数组
+        for (int i = 0; i < arr.length; i++) {
+            if (max < arr[i]) {
+                //拿元素进行比较，求最大值
+                max = arr[i];
+            } else if (min > arr[i]) {
+                //求最小值
+                min = arr[i];
+            }
+            //求和
+            sum += arr[i];
+        }
+        ave = (sum - max - min) / 10;
+        System.out.print("\n最大值为：" + max);
+        System.out.print("\n最小值为：" + min);
+        System.out.print("\n平均成绩为：" + ave);
+    }
+}
+
+```
+
diff --git "a/05 \346\236\227\344\274\237\345\275\254/20221213 \344\271\230\346\263\225\345\217\243\350\257\200,\351\230\266\347\272\247\345\244\251\347\204\266\346\260\224.md" "b/05 \346\236\227\344\274\237\345\275\254/20221213 \344\271\230\346\263\225\345\217\243\350\257\200,\351\230\266\347\272\247\345\244\251\347\204\266\346\260\224.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a9cee28ae8324e0ce713364cef5fb7b7b03bf767
--- /dev/null
+++ "b/05 \346\236\227\344\274\237\345\275\254/20221213 \344\271\230\346\263\225\345\217\243\350\257\200,\351\230\266\347\272\247\345\244\251\347\204\266\346\260\224.md"	
@@ -0,0 +1,63 @@
+# 作业
+
+1. 实付445.4元
+
+   一档阶梯(0-240:3.375元/方)
+
+   二档阶梯(241-360:405元/方)
+
+   三档阶梯(361-99999999:5.06元/方)
+
+   解题思路：
+
+​		已知 购买100立方 总共付了445.4
+​	// 第二梯度 4.05元/立方 假设全买第二梯度 100立方得到 405元// 第三梯度 5.06元/立方 假设全	
+
+​		//第三梯度 100立方得到 506元
+​		// 所以得到结论，就是要100立方中，部分买第二档，剩下的买第三档
+​		// 假设第二档买了X立方，第三档,就是多少100-x立方?
+​		// x*4.05+(100-x)*5.06 == 445.4 问x的取值范围是多少 1-100
+​		// 可以搞个循环
+
+
+
+```java
+package 作业;
+
+public class 天然气 {
+    public static void main(String[] args) {
+        for (int i=1;i<=100;i++){
+            if (i*4.05+(100-i)*5.06==445.4){
+                System.out.println("第二档是："+i+"立方\n第三档是："+(100-i)+"立方");
+            }
+        }
+    }
+}
+
+```
+
+2. 乘法口诀
+
+
+
+
+
+```java
+package 作业;
+
+public class 乘法 {
+    public static void main(String[] args) {
+        //外层的循环做被乘的数
+        for (int i=1;i<=9;i++){
+            //里层循环做乘数
+            for (int j=1;j<=i;j++){
+                System.out.print(j+"*"+i+"="+j*i+"\t");
+            }
+            System.out.println();
+        }
+
+    }
+}
+
+```
+
diff --git "a/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\204.png" "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\204.png"
new file mode 100644
index 0000000000000000000000000000000000000000..ff3d21d1fc06d61188332cfb711b5fe8c77ffeb5
Binary files /dev/null and "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\204.png" differ
diff --git "a/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2041.png" "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2041.png"
new file mode 100644
index 0000000000000000000000000000000000000000..ff3d21d1fc06d61188332cfb711b5fe8c77ffeb5
Binary files /dev/null and "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2041.png" differ
diff --git "a/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2043.png" "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2043.png"
new file mode 100644
index 0000000000000000000000000000000000000000..73c0513584add6ee262a2a1da7a5654ea7f66912
Binary files /dev/null and "b/05 \346\236\227\344\274\237\345\275\254/img/\346\225\260\347\273\2043.png" differ