diff --git "a/45 \347\216\213\345\274\272/20221205switch\350\257\255\345\217\245.md" "b/45 \347\216\213\345\274\272/20221205switch\350\257\255\345\217\245.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c54da459ecd5c47950100a5a1905a955296a8600
--- /dev/null
+++ "b/45 \347\216\213\345\274\272/20221205switch\350\257\255\345\217\245.md"	
@@ -0,0 +1,468 @@
+### switch语句
+
+格式
+
+```java
+switch (表达式) {
+case 1:
+语句体1;
+break;
+case 2:
+语句体2;
+break;
+...
+default:
+语句体n+1;
+break;
+}
+```
+
+执行流程：首先计算出表达式的值其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+### 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;
+}
+}
+}
+```
+
+### 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.p
+rintln("休息日");
+break;
+default:
+System.out.println("您的输入有误");
+break;
+}
+}
+} 
+```
+
+```java
+
+
+
+
+
+```
+
+### 作业
+
+```java
+## 两种分支（if-else和Switch）
+
+## 1. **if-else**语句
+
+**if可以判定一个范围**
+
+第一种格式：
+
+```java
+格式：
+    if（条件）{
+    语句体；
+}
+```
+
+范例：
+
+```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("结束");
+	}
+}
+```
+
+
+
+第二种格式：
+
+```java
+格式：
+    if(条件){
+        语句体;
+    }else{
+        语句体；
+    }
+```
+
+范例：
+
+```java
+public class Demo2If {
+	public static void main(String[] args) {
+		// 程序判断一个数, 是奇数还是偶数
+		int num = 9;
+		
+		if(num % 2 == 0){
+			System.out.println("偶数");
+		}else{
+			System.out.println("奇数");
+		}
+	}
+}
+```
+
+第三种格式：
+
+```java
+格式：
+    if(条件1){
+        语句体；
+    }else if(条件2){
+        语句体；
+    }
+…
+    else{
+        语句体n+1；
+    }
+```
+
+范例：
+
+```java
+public class Demo3If {
+	public static void main(String[] args){
+		int score = 65;
+		if(score >= 90 && score <= 100){
+			System.out.println("优秀");
+		}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("成绩有误!");
+		}
+	}
+}
+```
+
+
+
+## 2. Switch语句
+
+**只能判断精准的某一个值**
+
+格式：
+
+```java
+switch(条件) {
+    case 1:
+        语句体；
+            break;
+    case 2:
+        语句体；
+            break;
+        ...
+            default:
+        语句体n+1;
+        break;
+}
+```
+
+
+
+范例：
+
+```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;
+       }
+    }
+}
+```
+
+## 作业：
+
+某市不同车牌的出租车3千米的起步价和计费分别为：夏利3元，三千里以外，2.1元/千米；富康4元，3千米以外，2.4元/千米；桑塔纳5元，三千米以外，2.7元/千米，编程实现从键盘输入乘车的车型及行车千米数，输出应付车费。
+
+```java
+import java.util.Scanner;
+
+public class zy {
+    public static void main(String[] args) {
+        Scanner zy = new Scanner(System.in);
+        System.out.println("请输入车型：夏利/富康/桑塔纳");
+        String car = zy .next();
+        System.out.println("请输入公里数:");
+        double km = zy.nextDouble();
+        double m;
+        switch (car){
+            case "夏利":
+                if (km<=3){
+                    m = 3;
+                }else {
+                    m = (km - 3) * 2.1 + 3;
+                }
+                System.out.println( m );
+                break;
+            case "富康":
+                if (km<=3){
+                    m = 4;
+                }else {
+                    m = (km - 3) * 2.4 + 3;
+                }
+                System.out.println( m );
+                break;
+            case "桑塔纳":
+                if (km<=3){
+                    m = 5;
+                }else {
+                    m = (km - 3) * 2.7 + 3;
+                }
+                System.out.println( m );
+                break;
+            default:
+                System.out.println("无车匹配");
+        }
+
+    }
+}
+
+```
+
+使用switch和if语句算出今天是今年的第几天(提示：以3月3日为例，应该先把前两个月的天数加起来，然后再加上3天即为本年的第几天；需要考虑闰年的情况，如果输入的年份是闰年且输入的月份大于或等于3，需要多加1天)。
+
+```java
+import java.util.Scanner;
+
+public class zy {
+    public static void main(String[] args) {
+//        键盘输入年月日
+        Scanner zy = new Scanner(System.in);
+        System.out.println("请输入年份：");
+        int year = zy.nextInt();
+        if (year <= 0){
+            System.out.println("你输入的年份有误");
+        }else {
+            System.out.println("请输入月份：");
+            int month = zy.nextInt();
+            if (!(month >= 1 && month <= 12)){
+                System.out.println("你输入的月份有误");
+            }else {
+                System.out.println("请输入号：");
+                int day = zy.nextInt();
+                if (!(day >= 1 && day <= 31)){
+                    System.out.println("你输入的号有误");
+                }else {
+                    int s =0;
+                    int two;
+                    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
+                        two = 29;
+                    }else {
+                        two = 28;
+                    }
+                    switch (month){
+                        case 1:
+                            s = day;
+                            break;
+                        case 2:
+                            s = 31 + day;
+                            break;
+                        case 3:
+                            s = 31 + two + day;
+                            break;
+                        case 4:
+                            s = 31 + two + 31 + day;
+                            break;
+                        case 5:
+                            s = 31 + two + 31 + 30 + day;
+                            break;
+                        case 6:
+                            s = 31 + two + 31 + 30 + 31 + day;
+                            break;
+                        case 7:
+                            s = 31 + two + 31 + 30 + 31 + 30 + day;
+                            break;
+                        case 8:
+                            s = 31 + two + 31 + 30 + 31 + 30 + 31 + day;
+                            break;
+                        case 9:
+                            s = 31 + two + 31 + 30 + 31 + 30 + 31 + 31 + day;
+                            break;
+                        case 10:
+                            s = 31 + two + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
+                            break;
+                        case 11:
+                            s = 31 + two + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
+                            break;
+                        case 12:
+                            s = 31 + two + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
+                            break;
+                    }
+                    System.out.println(year + "年" + month + "月" + day + "日是" +year + "年的第" + s + "天");
+                }
+            }
+        }
+    }
+}
+
+```
+
+编写一个程序，根据用户输入的一个字符，判断该字符是不是字母，如果是字母，判断该字母是声母还是韵母，是大写字母还是小写字母；如果不是字母，则输出“你输入的字符不是字母”
+
+```java
+import java.util.Scanner;
+
+public class zy {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入一个字符：");
+        char a = sc.next().charAt(0);
+        //        A-Z  65-90
+        //        a-z  97-122
+        if (a >= 65 && a <= 90 || a >= 97 && a <= 122) {
+            if (a >= 65 && a <= 90) {
+                System.out.println(a + "是大写字母");
+            } else if (a >= 97 && a <= 122) {
+                System.out.println(a + "是小写字母");
+            }
+            switch (a) {
+                case 'a':
+                case 'e':
+                case 'i':
+                case 'o':
+                case 'u':
+                case 'v':
+                case 'A':
+                case 'E':
+                case 'I':
+                case 'O':
+                case 'U':
+                case 'V':
+                    System.out.println(a + "是韵母");
+                    break;
+                default:
+                    System.out.println(a + "是声母");
+            }
+        }else {
+            System.out.println("你输入的字符不是字母");
+        }
+
+
+
+
+```
+```
+
+
diff --git "a/45 \347\216\213\345\274\272/20221207 for.md" "b/45 \347\216\213\345\274\272/20221207 for.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c783920fe27841a2ea034d7d8d73b9c00d2fcf4e
--- /dev/null
+++ "b/45 \347\216\213\345\274\272/20221207 for.md"	
@@ -0,0 +1,219 @@
+## 循环语句
+
+1. for循环
+
+   循环：
+
+   循环语句可以在满足循环的条件的情况下，反复执行一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环一直执行下去，形成死循环。
+
+   for循环格式：
+
+   ```java
+   for(初始语句;条件判断语句;条件控制语句){
+       循环语句;
+   }
+   ```
+
+   格式解释：
+
+   1.初始语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+
+   2.条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+
+   3.循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+
+   4.条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+    **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);
+}
+}
+}
+```
+
+## while循环语句
+
+while循环格式
+
+```java
+初始化语句;
+while (条件判断语句) {
+循环体语句;
+条件控制语句;
+}
+```
+
+while循环执行流程：
+
+①执行初始化语句
+
+②执行条件判断语句，看其结果是true还是false
+
+ 如果是false，循环结束
+
+ 如果是true，继续执行
+
+③执行循环体语句
+
+④执行条件控制语句
+
+⑤回到②继续
+
+示例代码：
+
+```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++;
+}
+}
+}
+```
+
+## do while循环语句
+
+```java
+初始化语句;
+do {
+循环体语句;
+条件控制语句;
+}while(条件判断语句);
+```
+
+执行流程：
+
+① 执行初始化语句
+
+② 执行循环体语句
+
+③ 执行条件控制语句
+
+④ 执行条件判断语句，看其结果是true还是false
+
+如果是false，循环结束
+
+如果是true，继续执行
+
+⑤ 回到②继续
+
+示例代码：
+
+```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);
+}
+}
+```
+
+## 三种语句的区别
+
+三种循环的区别
+
+for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
+
+do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后
+
+判断）
+
+for循环和while的区别
+
+条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能
+
+再次被访问到了
+
+条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束
+
+后，该变量还可以继续使用
+
+死循环（无限循环）的三种格式
+
+\1. for(;;){}
+
+\2. while(true){}
+
+\3. do {} while(true);
+
+## 死循环
+
+死循环格式
+
+```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("看看我能被执行吗?~"); // 无法访问的语句
+}
+}
+```
\ No newline at end of file
diff --git "a/45 \347\216\213\345\274\272/20221209 \346\225\260\347\273\204.md" "b/45 \347\216\213\345\274\272/20221209 \346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0d78a3816d34a86622c30523af7d321430b0a214
--- /dev/null
+++ "b/45 \347\216\213\345\274\272/20221209 \346\225\260\347\273\204.md"	
@@ -0,0 +1,604 @@
+## 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](.\4img\1591007817165.png)
+
+### 1.7 两个数组内存图
+
+![1591007925899](.\4img\1591007925899.png)
+
+### 1.8 多个数组指向相同内存图
+
+![1591007957052](.\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);
+      }
+  }
+  ```
+
+## 作业
+
+```java
+public class a1208 {
+    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 num = sc.nextInt();
+            if(num>randomNum){
+                System.out.println("猜大了");
+            }else if (num<randomNum) {
+                System.out.println("猜小了");
+            }else {
+                System.out.println("恭喜你猜对了");
+                break;
+            }
+        }
+        System.out.println("感谢您的使用");
+    }
+}
+```
+
+```java
+public class b1208 {
+    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 c = arr[a];
+            arr[a]=arr[b];
+            arr[b]=c;
+        }
+        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/45 \347\216\213\345\274\272/\344\275\234\344\270\232.md" "b/45 \347\216\213\345\274\272/\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8145b3c8e20ceac6edc150b535354d706deb2deb
--- /dev/null
+++ "b/45 \347\216\213\345\274\272/\344\275\234\344\270\232.md"	
@@ -0,0 +1,37 @@
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class a {
+    public static void main(String[] args) {
+        //闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，
+        // 存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分
+        // 【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】，
+        int[] arr = new int[10];
+        int sum = 0;
+        Random r = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = r.nextInt(100) + 1;
+            sum += arr[i];
+        }
+        System.out.println(Arrays.toString(arr));
+        int max = arr[0];
+        int min = arr[0];
+        for (int i = 1; i < arr.length; i++) {
+            if (max < arr[i]) {
+                max = arr[i];
+            }
+            if (min > arr[i]) {
+                min = arr[i];
+            }
+        }
+        System.out.println("总分："+ sum);
+        System.out.println("最大值："+ max);
+        System.out.println("最小值："+ min);
+        double a = (sum-max-min)*1.0/(arr.length-2);
+        System.out.println("平均值为："+ a);
+    }
+}
+```
+
+