diff --git "a/38 \351\273\204\346\255\243\347\204\225/20221202\344\270\244\347\247\215\345\210\206\346\224\257\357\274\210if-else\345\222\214Switch\357\274\211.md" "b/38 \351\273\204\346\255\243\347\204\225/20221202\344\270\244\347\247\215\345\210\206\346\224\257\357\274\210if-else\345\222\214Switch\357\274\211.md"
new file mode 100644
index 0000000000000000000000000000000000000000..96aceac78f2bc386a244ba60bc30a31b5f5fc4c6
--- /dev/null
+++ "b/38 \351\273\204\346\255\243\347\204\225/20221202\344\270\244\347\247\215\345\210\206\346\224\257\357\274\210if-else\345\222\214Switch\357\274\211.md"	
@@ -0,0 +1,342 @@
+## 两种分支（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/38 \351\273\204\346\255\243\347\204\225/20221206 \345\276\252\347\216\257\350\257\255\345\217\245\347\254\224\350\256\260.md" "b/38 \351\273\204\346\255\243\347\204\225/20221206 \345\276\252\347\216\257\350\257\255\345\217\245\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f1ef2d261dfed0b0deba6d05d047687c7760e56d
--- /dev/null
+++ "b/38 \351\273\204\346\255\243\347\204\225/20221206 \345\276\252\347\216\257\350\257\255\345\217\245\347\254\224\350\256\260.md"	
@@ -0,0 +1,238 @@
+## 循环语句
+
+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("看看我能被执行吗?~"); // 无法访问的语句
+}
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/38 \351\273\204\346\255\243\347\204\225/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\345\217\212\346\225\260\347\273\204\344\275\234\344\270\232.md" "b/38 \351\273\204\346\255\243\347\204\225/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\345\217\212\346\225\260\347\273\204\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9c1d06a77a42f3a18e36b92787648adede17c657
--- /dev/null
+++ "b/38 \351\273\204\346\255\243\347\204\225/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\345\217\212\346\225\260\347\273\204\344\275\234\344\270\232.md"	
@@ -0,0 +1,364 @@
+## 跳转语句
+
+跳转控制语句（break）
+
+跳出循环，结束循环
+
+跳转控制语句（continue）
+
+跳过本次循环，继续下次循环
+
+注意： continue只能在循环中进行使用！
+
+## **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:代表数组的长度
+
+```jav
+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);
+
+    }
+}
+
+```
+
+##  数组元素访问
+
+什么是索引:
+
+每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 	
+
+访问数组元素格式：数组名[索引];
+
+```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]);
+    }
+}
+```
+
+## 内存分配
+
+内存概述:
+
+​	内存是计算机中的重要原件，临时存储区域，作用是运行程序。
+
+​	我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
+
+​	必须放进内存中才能运行，运行完毕后会清空内存。 
+
+​	Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。 
+
+ java中的内存分配:
+
+目前我们只需要记住两个内存，分别是：栈内存和堆内存
+
+| 区域名称   | 作用                                                       |
+| ---------- | ---------------------------------------------------------- |
+| 寄存器     | 给CPU使用，和我们开发无关。                                |
+| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。          |
+| 方法区     | 存储可以运行的class文件。                                  |
+| 堆内存     | 存储对象或者数组，new来创建的，都存储在堆内存。            |
+| 方法栈     | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
+
+## 数组的静态初始化
+
+什么是静态初始化:
+
+在创建数组时，直接将元素确定	
+
+完整版格式
+
+```java
+数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+```
+
+简化版格式
+
+```java
+数据类型[] 数组名 = {元素1,元素2,...};
+```
+
+```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]);
+
+    }
+}
+```
+
+## 作业
+
+猜数字游戏
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class 猜数字游戏 {
+    public static void main(String[] args) {
+//        创建扫描器
+        Scanner sc = new Scanner(System.in);
+//        随机数
+        Random r = new Random();
+        int b = r.nextInt(90)+10;
+        int c = 0;
+        a:while (true){
+            System.out.println("请输入数字");
+            int a = sc.nextInt();
+            if (a>b){
+                System.out.println("猜大了");
+            }else if (a==b){
+                System.out.println("猜对了");
+                break ;
+
+            }else {
+                System.out.println("猜小了");
+            }
+            c++;
+            if (c==3){
+                System.out.println("本轮游戏结束，继续请按Y或y，退出请按N或n");
+                char d = sc.next().charAt(0);
+                switch (d){
+                    case 'Y':
+                    case 'y':
+                        c=0;
+                        break ;
+                    case 'N':
+                    case 'n':
+                        break a ;
+                    default:
+                        System.out.println("mistake");
+                        break ;
+                }
+            }
+        }
+    }
+}
+
+```
+
+找最大
+
+```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);
+    }
+}
+```
+
diff --git "a/38 \351\273\204\346\255\243\347\204\225/20221209\346\225\260\347\273\204\347\237\245\350\257\206\345\217\212\344\275\234\344\270\232.md" "b/38 \351\273\204\346\255\243\347\204\225/20221209\346\225\260\347\273\204\347\237\245\350\257\206\345\217\212\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6c3317e9319ca44f646b1edac0541d628c58274f
--- /dev/null
+++ "b/38 \351\273\204\346\255\243\347\204\225/20221209\346\225\260\347\273\204\347\237\245\350\257\206\345\217\212\344\275\234\344\270\232.md"	
@@ -0,0 +1,293 @@
+## 数组常见的两个问题
+
+1，索引越界异常
+
+出现原因：
+
+```java
+public class ArrayDemo{
+     public static void main(String[] args){
+         int [] arr = new int[3];
+         System.out.println(arr[3]);
+     }
+}
+```
+
+数组长度为三，索引范围是0~2；但是我们访问的是一个三的索引。
+
+计算机是从零开始计算，我们的输入的数组为三，计算机翻译过来就是0.1.2所以该数组最大输出只能是2.
+
+程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+2.空指针异常
+
+出现原因：
+
+```java
+public class ArrayDemo {
+    public static void main(String[] args) {
+        int[] arr = new int[3];
+
+        //把null赋值给数组
+        arr = null;
+        System.out.println(arr[0]);
+    }
+}
+```
+
+null是没有的意思，将数组赋值给没有，这个是错的。
+
+arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+## 数组遍历
+
+就是将数组里的每一个值拿出来，
+
+```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.定义变量，保存数组0索引以上的元素
+
+2.遍历数组，将每一个值都拿出来
+
+3.将遍历到的元素和保存数组0索引上值的变量进行比较
+
+4.如果数组元素的值大于了变量的值，变量记录住新的值
+
+5.数组循环遍历结束，变量保存的就是数组中的最大值 
+
+代码实现:
+
+```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);
+    }
+}
+
+```
+
+## 数组元素求和
+
+需求：键盘录入5个整数（也可以使用随机数Random），存储到数组中，并对数组求和
+
+实现思路：
+    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);
+
+    }
+}
+
+```
+
+## 数组查找
+
+需求：
+    已知一个数组 arr = {19, 28, 37, 46, 50}; （也可以使用随机数Random），键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引   值。
+    
+
+实现思路：
+    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);
+    }
+}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);
+    }
+}
+```
+
+## 作业
+
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class 评委打分去高去低 {
+    public static void main(String[] args) {
+        //闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，
+        // 存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分
+        // 需求：去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值
+        //定义数组
+        int [] arr = new int[10];
+        //创建随机数
+        Random r = new Random();
+        //arr.length，返回的是这个数组的长度，此处我们定义的数组的长度为10，所以arr.length的返回值也是10
+        int sum = 0;//求总和
+        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 average = (sum-max-min)*1.0/(arr.length-2);
+        System.out.println("平均值为："+ average);
+    }
+}
+
+```
+