From 832eac5dfef06462b49c0ab3af6916dd777dfb12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E4=BF=8A=E5=93=B2?= <2361967167@qq.com>
Date: Tue, 6 Dec 2022 07:15:30 +0800
Subject: [PATCH 1/4] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...72\347\241\200\345\221\275\344\273\244.md" |  17 -
 ...55\345\222\214\345\276\252\347\216\257.md" | 387 ++++++++++++++++++
 2 files changed, 387 insertions(+), 17 deletions(-)
 delete mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221201 DOS\345\237\272\347\241\200\345\221\275\344\273\244.md"
 create mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"

diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221201 DOS\345\237\272\347\241\200\345\221\275\344\273\244.md" "b/24 \351\231\210\344\277\212\345\223\262/20221201 DOS\345\237\272\347\241\200\345\221\275\344\273\244.md"
deleted file mode 100644
index af22f3b..0000000
--- "a/24 \351\231\210\344\277\212\345\223\262/20221201 DOS\345\237\272\347\241\200\345\221\275\344\273\244.md"	
+++ /dev/null
@@ -1,17 +0,0 @@
-常用DOS命令
-dir：列出当前目录下的文件以及文件夹
-md：创建目录
-rd：删除目录
-cd：进入指定目录
-cd..：退回到上一级目录
-cd\：退回到根目录
-del：删除文件
-exit：退出DOS命令行
-
-Java两种核心机制
-Java虚拟机（Java Virtal Machine），JVM
-垃圾收集机制（Garbage Collection），GC
-
-Java语言特性：跨平台性
-有了JVM，同一个java程序在三个不同的操作系统中都可以执行。
-这样就实现了java程序的跨平台性。
diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md" "b/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"
new file mode 100644
index 0000000..ebb62c9
--- /dev/null
+++ "b/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"	
@@ -0,0 +1,387 @@
+## if语句格式
+
+### 格式1：
+
+```
+if (关系表达式) {
+    语句体;	
+}
+```
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体
+
+③如果关系表达式的值为false就不执行语句体
+
+④继续执行后面的语句内容
+
+示例：
+
+```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("结束");
+	}
+}
+```
+
+### 格式2：
+
+```
+格式：
+if (关系表达式) {
+    语句体1;	
+} else {
+    语句体2;	
+}
+```
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体1
+
+③如果关系表达式的值为false就执行语句体2
+
+④继续执行后面的语句内容
+
+示例：奇偶数
+
+​	任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+```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(理解)
+
+```
+格式：
+if (关系表达式1) {
+    语句体1;	
+} else if (关系表达式2) {
+    语句体2;	
+} 
+…
+else {
+    语句体n+1;
+}
+```
+
+执行流程：
+
+①首先计算关系表达式1的值
+
+②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+④…
+
+⑤如果没有任何关系表达式为true，就执行语句体n+1。
+
+示例：
+
+​	定义一个在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.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("成绩有误!");
+		}
+	}
+}
+```
+
+## switch语句
+
+### 分支语句switch语句
+
+格式：
+
+```java
+switch (表达式) {
+	case 1:
+		语句体1;
+		break;
+	case 2:
+		语句体2;
+		break;
+	...
+	default:
+		语句体n+1;
+		break;
+}
+
+```
+
+执行流程： 
+
+1、首先计算出表达式的值 
+
+2、其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结 束。 
+
+3、最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+### switch语句case穿透
+
+概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透 
+
+需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日 
+
+示例代码：
+
+```java
+public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入星期数:");
+		int week = sc.nextInt();
+		switch(week){
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+			case 5:
+				System.out.println("工作日");
+				break;
+			case 6:
+			case 7:
+				System.out.println("休息日");
+				break;
+			default:
+				System.out.println("您的输入有误");
+				break;
+		}
+	}
+}
+```
+
+### for循环
+
+#### 循环
+
+循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环 体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循 环，否则循环将一直执行下去，形 成死循环。
+
+#### 格式
+
+```java
+for (初始化语句;条件判断语句;条件控制语句) {
+	循环体语句;
+}
+
+```
+
+#### 格式解释
+
+初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样 
+
+条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去 
+
+循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情 
+
+条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+#### 执行流程
+
+①执行初始化语句 
+
+②执行条件判断语句，看其结果是true还是false 
+
+​		如果是false，循环结束 
+
+​		如果是true，继续执行 
+
+③执行循环体语句 
+
+④执行条件控制语句 
+
+⑤回到②继续
+
+#### 案例
+
+输出数据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);
+		}
+	}
+}
+```
+
+求1-5数据和
+
+需求：求1-5之间的数据和，并把求和结果在控制台输出 
+
+示例代码：
+
+```java
+public class ForTest02 {
+	public static void main(String[] args) {
+		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+		int sum = 0;
+		//从1开始到5结束的数据，使用循环结构完成
+		for(int i=1; i<=5; i++) {
+			//将反复进行的事情写入循环结构内部
+				// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
+			sum += i;
+			/*
+				sum += i; sum = sum + i;
+				第一次：sum = sum + i = 0 + 1 = 1;
+				第二次：sum = sum + i = 1 + 2 = 3;
+				第三次：sum = sum + i = 3 + 3 = 6;
+				第四次：sum = sum + i = 6 + 4 = 10;
+				第五次：sum = sum + i = 10 + 5 = 15;
+			*/
+		}
+		//当循环执行完毕时，将最终数据打印出来
+		System.out.println("1-5之间的数据和是：" + sum);
+	}
+}
+```
+
+本题要点： 
+
+​		今后遇到的需求中，如果带有求和二字，请立即联想到求和变量 
+
+​		求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+
+### 作业
+
+```java
+package text;
+
+import java.util.Scanner;
+
+public class zy01 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("夏利扣1；富康扣2；桑塔纳扣3");
+        int carNumber = sc.nextInt();
+        System.out.println("请输入公里数");
+        double km = sc.nextInt();
+
+        switch (carNumber){
+            case 1:
+                if(km <= 3){
+                    System.out.println("价格为3元");
+                }else {
+                    double momeny = (km - 3)*2.1 + 3;
+                    System.out.println("价格为" + momeny + '元');
+                }
+                break;
+            case 2:
+                if(km <= 3){
+                    System.out.println("价格为4元");
+                }else {
+                    double momeny = (km - 3)*2.4 + 4;
+                    System.out.println("价格为" + momeny + '元');
+                }
+                break;
+            case 3:
+                if(km <= 3){
+                    System.out.println("价格为5元");
+                }else {
+                    double momeny = (km - 3)*2.7 + 5;
+                    System.out.println("价格为" + momeny + '元');
+                }
+                break;
+        }
+    }
+}
+```
+
+~~~java
+package text;
+
+import java.util.Scanner;
+
+public class zy02 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入年份");
+        int year = sc.nextInt();
+        System.out.println("请输入月份");
+        int month = sc.nextInt();
+        System.out.println("请输入日期");
+        int date = sc.nextInt();
+        int day = 0;
+
+        for (int i = 1; i < month+1; i++){
+            switch (i){
+                case 1:
+                case 3:
+                case 5:
+                case 7:
+                case 8:
+                case 10:
+                case 12:
+                    day += 31;
+                    break;
+                case 4:
+                case 6:
+                case 9:
+                case 11:
+                    day += 30;
+                case 2:
+                    if((year%4==0 && year%100!=0) || year%400 ==0){
+                        day += 29;
+                    }else {
+                        day += 28;
+                    }
+            }
+        }
+        System.out.println("今天是今年的第" + (day+date) +"天");
+    }
+}
+~~~
+
-- 
Gitee


From 8a56e197d441a63f8ead5a8650d63534e0fe24d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E4=BF=8A=E5=93=B2?= <2361967167@qq.com>
Date: Wed, 7 Dec 2022 23:28:14 +0800
Subject: [PATCH 2/4] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...55\345\222\214\345\276\252\347\216\257.md" | 387 ------------------
 .../20221207 \345\276\252\347\216\257.md"     | 236 +++++++++++
 2 files changed, 236 insertions(+), 387 deletions(-)
 delete mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"
 create mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"

diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md" "b/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"
deleted file mode 100644
index ebb62c9..0000000
--- "a/24 \351\231\210\344\277\212\345\223\262/20221205 \345\210\206\346\224\257\345\210\244\346\226\255\345\222\214\345\276\252\347\216\257.md"	
+++ /dev/null
@@ -1,387 +0,0 @@
-## if语句格式
-
-### 格式1：
-
-```
-if (关系表达式) {
-    语句体;	
-}
-```
-
-执行流程：
-
-①首先计算关系表达式的值
-
-②如果关系表达式的值为true就执行语句体
-
-③如果关系表达式的值为false就不执行语句体
-
-④继续执行后面的语句内容
-
-示例：
-
-```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("结束");
-	}
-}
-```
-
-### 格式2：
-
-```
-格式：
-if (关系表达式) {
-    语句体1;	
-} else {
-    语句体2;	
-}
-```
-
-执行流程：
-
-①首先计算关系表达式的值
-
-②如果关系表达式的值为true就执行语句体1
-
-③如果关系表达式的值为false就执行语句体2
-
-④继续执行后面的语句内容
-
-示例：奇偶数
-
-​	任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
-
-```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(理解)
-
-```
-格式：
-if (关系表达式1) {
-    语句体1;	
-} else if (关系表达式2) {
-    语句体2;	
-} 
-…
-else {
-    语句体n+1;
-}
-```
-
-执行流程：
-
-①首先计算关系表达式1的值
-
-②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
-
-③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
-
-④…
-
-⑤如果没有任何关系表达式为true，就执行语句体n+1。
-
-示例：
-
-​	定义一个在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.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("成绩有误!");
-		}
-	}
-}
-```
-
-## switch语句
-
-### 分支语句switch语句
-
-格式：
-
-```java
-switch (表达式) {
-	case 1:
-		语句体1;
-		break;
-	case 2:
-		语句体2;
-		break;
-	...
-	default:
-		语句体n+1;
-		break;
-}
-
-```
-
-执行流程： 
-
-1、首先计算出表达式的值 
-
-2、其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结 束。 
-
-3、最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
-
-### switch语句case穿透
-
-概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透 
-
-需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日 
-
-示例代码：
-
-```java
-public static void main(String[] args){
-		Scanner sc = new Scanner(System.in);
-		System.out.println("请输入星期数:");
-		int week = sc.nextInt();
-		switch(week){
-			case 1:
-			case 2:
-			case 3:
-			case 4:
-			case 5:
-				System.out.println("工作日");
-				break;
-			case 6:
-			case 7:
-				System.out.println("休息日");
-				break;
-			default:
-				System.out.println("您的输入有误");
-				break;
-		}
-	}
-}
-```
-
-### for循环
-
-#### 循环
-
-循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环 体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循 环，否则循环将一直执行下去，形 成死循环。
-
-#### 格式
-
-```java
-for (初始化语句;条件判断语句;条件控制语句) {
-	循环体语句;
-}
-
-```
-
-#### 格式解释
-
-初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样 
-
-条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去 
-
-循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情 
-
-条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
-
-#### 执行流程
-
-①执行初始化语句 
-
-②执行条件判断语句，看其结果是true还是false 
-
-​		如果是false，循环结束 
-
-​		如果是true，继续执行 
-
-③执行循环体语句 
-
-④执行条件控制语句 
-
-⑤回到②继续
-
-#### 案例
-
-输出数据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);
-		}
-	}
-}
-```
-
-求1-5数据和
-
-需求：求1-5之间的数据和，并把求和结果在控制台输出 
-
-示例代码：
-
-```java
-public class ForTest02 {
-	public static void main(String[] args) {
-		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
-		int sum = 0;
-		//从1开始到5结束的数据，使用循环结构完成
-		for(int i=1; i<=5; i++) {
-			//将反复进行的事情写入循环结构内部
-				// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
-			sum += i;
-			/*
-				sum += i; sum = sum + i;
-				第一次：sum = sum + i = 0 + 1 = 1;
-				第二次：sum = sum + i = 1 + 2 = 3;
-				第三次：sum = sum + i = 3 + 3 = 6;
-				第四次：sum = sum + i = 6 + 4 = 10;
-				第五次：sum = sum + i = 10 + 5 = 15;
-			*/
-		}
-		//当循环执行完毕时，将最终数据打印出来
-		System.out.println("1-5之间的数据和是：" + sum);
-	}
-}
-```
-
-本题要点： 
-
-​		今后遇到的需求中，如果带有求和二字，请立即联想到求和变量 
-
-​		求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
-
-### 作业
-
-```java
-package text;
-
-import java.util.Scanner;
-
-public class zy01 {
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("夏利扣1；富康扣2；桑塔纳扣3");
-        int carNumber = sc.nextInt();
-        System.out.println("请输入公里数");
-        double km = sc.nextInt();
-
-        switch (carNumber){
-            case 1:
-                if(km <= 3){
-                    System.out.println("价格为3元");
-                }else {
-                    double momeny = (km - 3)*2.1 + 3;
-                    System.out.println("价格为" + momeny + '元');
-                }
-                break;
-            case 2:
-                if(km <= 3){
-                    System.out.println("价格为4元");
-                }else {
-                    double momeny = (km - 3)*2.4 + 4;
-                    System.out.println("价格为" + momeny + '元');
-                }
-                break;
-            case 3:
-                if(km <= 3){
-                    System.out.println("价格为5元");
-                }else {
-                    double momeny = (km - 3)*2.7 + 5;
-                    System.out.println("价格为" + momeny + '元');
-                }
-                break;
-        }
-    }
-}
-```
-
-~~~java
-package text;
-
-import java.util.Scanner;
-
-public class zy02 {
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        System.out.println("请输入年份");
-        int year = sc.nextInt();
-        System.out.println("请输入月份");
-        int month = sc.nextInt();
-        System.out.println("请输入日期");
-        int date = sc.nextInt();
-        int day = 0;
-
-        for (int i = 1; i < month+1; i++){
-            switch (i){
-                case 1:
-                case 3:
-                case 5:
-                case 7:
-                case 8:
-                case 10:
-                case 12:
-                    day += 31;
-                    break;
-                case 4:
-                case 6:
-                case 9:
-                case 11:
-                    day += 30;
-                case 2:
-                    if((year%4==0 && year%100!=0) || year%400 ==0){
-                        day += 29;
-                    }else {
-                        day += 28;
-                    }
-            }
-        }
-        System.out.println("今天是今年的第" + (day+date) +"天");
-    }
-}
-~~~
-
diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md" "b/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"
new file mode 100644
index 0000000..26e02c0
--- /dev/null
+++ "b/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"	
@@ -0,0 +1,236 @@
+####  for循环格式：
+
+```java
+for (初始化语句;条件判断语句;条件控制语句) {
+循环体语句;
+}
+```
+
+#### 执行流程：
+
+①执行初始化语句
+
+②执行条件判断语句，看其结果是true还是false
+
+ 如果是false，循环结束
+
+ 如果是true，继续执行
+
+③执行循环体语句
+
+④执行条件控制语句
+
+⑤回到②继续
+
+#### for循环案例
+
+需求：在控制台输出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);
+		}
+	}
+}
+```
+
+需求：求1-5之间的数据和，并把求和结果在控制台输出
+
+```java
+public class ForTest02 {
+	public static void main(String[] args) {
+		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+		int sum = 0;
+		//从1开始到5结束的数据，使用循环结构完成
+		for(int i=1; i<=5; i++) {
+			//将反复进行的事情写入循环结构内部
+			// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
+			sum += i;
+			/*
+				sum += i; sum = sum + i;
+				第一次：sum = sum + i = 0 + 1 = 1;
+				第二次：sum = sum + i = 1 + 2 = 3;
+				第三次：sum = sum + i = 3 + 3 = 6;
+				第四次：sum = sum + i = 6 + 4 = 10;
+                第五次：sum = sum + i = 10 + 5 = 15;
+			*/
+		}
+		//当循环执行完毕时，将最终数据打印出来
+		System.out.println("1-5之间的数据和是：" + sum);
+	}
+}
+```
+
+## 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++;
+		}
+	}
+}
+```
+
+## 循环细节
+
+#### 循环语句-dowhile循环
+
+```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);
+	}
+}
+```
+
+#### 三种循环的区别
+
+三种循环的区别
+
+1.for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
+
+2.do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后 判断）
+
+for循环和while的区别
+
+1.条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能 再次被访问到了
+
+2.条件控制语句所控制的自增变量，对于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
-- 
Gitee


From 47b29011e343b70769ef20e0fa3cd1695b8e316d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E4=BF=8A=E5=93=B2?= <2361967167@qq.com>
Date: Fri, 9 Dec 2022 12:32:40 +0800
Subject: [PATCH 3/4] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../20221207 \345\276\252\347\216\257.md"     | 236 ------------------
 ...2\346\225\260 \346\225\260\347\273\204.md" | 177 +++++++++++++
 2 files changed, 177 insertions(+), 236 deletions(-)
 delete mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"
 create mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"

diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md" "b/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"
deleted file mode 100644
index 26e02c0..0000000
--- "a/24 \351\231\210\344\277\212\345\223\262/20221207 \345\276\252\347\216\257.md"	
+++ /dev/null
@@ -1,236 +0,0 @@
-####  for循环格式：
-
-```java
-for (初始化语句;条件判断语句;条件控制语句) {
-循环体语句;
-}
-```
-
-#### 执行流程：
-
-①执行初始化语句
-
-②执行条件判断语句，看其结果是true还是false
-
- 如果是false，循环结束
-
- 如果是true，继续执行
-
-③执行循环体语句
-
-④执行条件控制语句
-
-⑤回到②继续
-
-#### for循环案例
-
-需求：在控制台输出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);
-		}
-	}
-}
-```
-
-需求：求1-5之间的数据和，并把求和结果在控制台输出
-
-```java
-public class ForTest02 {
-	public static void main(String[] args) {
-		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
-		int sum = 0;
-		//从1开始到5结束的数据，使用循环结构完成
-		for(int i=1; i<=5; i++) {
-			//将反复进行的事情写入循环结构内部
-			// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
-			sum += i;
-			/*
-				sum += i; sum = sum + i;
-				第一次：sum = sum + i = 0 + 1 = 1;
-				第二次：sum = sum + i = 1 + 2 = 3;
-				第三次：sum = sum + i = 3 + 3 = 6;
-				第四次：sum = sum + i = 6 + 4 = 10;
-                第五次：sum = sum + i = 10 + 5 = 15;
-			*/
-		}
-		//当循环执行完毕时，将最终数据打印出来
-		System.out.println("1-5之间的数据和是：" + sum);
-	}
-}
-```
-
-## 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++;
-		}
-	}
-}
-```
-
-## 循环细节
-
-#### 循环语句-dowhile循环
-
-```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);
-	}
-}
-```
-
-#### 三种循环的区别
-
-三种循环的区别
-
-1.for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
-
-2.do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后 判断）
-
-for循环和while的区别
-
-1.条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能 再次被访问到了
-
-2.条件控制语句所控制的自增变量，对于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/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md" "b/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"
new file mode 100644
index 0000000..940e21a
--- /dev/null
+++ "b/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"	
@@ -0,0 +1,177 @@
+##  1、随机数
+
+##### 1.1、生成随机数格式
+
+```java
+Random ran = new Random();//随机数生成
+int a = ran.nextInt(10); //代表[0,10） 0~9,随机数从0开始。
+
+//若要从1~15 则表示为
+int b = ran.nextInt(15)+1;
+```
+
+## 2、数组
+
+##### 2.1、数组的格式
+
+ 数组是可存储多个数据的组合
+
+格式如下：
+
+```java
+int[] arr={……}； //数组格式，数组必须初始化
+```
+
+##### 2.2、数组元素访问
+
+①索引从0开始
+
+②格式:
+
+```java
+arr [索引]
+```
+
+③获取数组的长度：
+
+```java
+int a= arr.length;//length为长度
+```
+
+##### 2.3、数组遍历
+
+就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+
+①从头到尾输出：
+
+```java
+int[] arr={……}
+for(int i=0 ;i<arr.length;i++){
+	System.out.println(arr[i]);
+}
+```
+
+②从头到尾累加：
+
+```java
+int[] arr={……}
+int sum = 0;
+for(int i=0 ;i<arr.length;i++){
+	sum + =arr[i];
+}
+System.out.println(sum);
+```
+
+③获取最大值
+
+最大值获取：从数组的所有元素中找出最大值。
+
+```java
+int[] arr={……};
+int max = arr[0];//取数组第一个数据为初始值
+for(int x=1 ; x<arr.length; x++){
+	if(arr[x] > max){
+	max=arr[x];
+	}
+}
+System.out.println(max);
+```
+
+④元素打乱:
+
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class D1 {
+    public static void main(String[] args) {
+        int[] arr = {1, 4, 5, 7, 8, 9};
+        System.out.println(Arrays.toString(arr));//先将数组打印出来
+        //创建随机数
+        Random ran = new Random();
+        //定义两个数据类型，分别赋值不同
+        int a = ran.nextInt(arr.length);
+        int b = ran.nextInt(arr.length);
+        //交换 定义一个新的变量，用于交换
+        int c = arr[a];
+        arr[a] = arr[b];
+        arr[b] = c;
+        //打乱后输出
+        System.out.println(Arrays.toString(arr));
+    }
+}
+```
+
+## 3、作业
+
+##### 3.1、猜数字
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class D2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        Random ran = new Random();
+        int a = ran.nextInt(90)+10;
+        int js = 0 ;
+        flag:while (true){
+            System.out.println("请输入你所猜的数字（10~99）:");
+            int csz = sc.nextInt();
+            if (csz>a){
+                System.out.println("猜大，重来！");
+            }else if(csz<a){
+                System.out.println("猜小，再来！");
+            }else {
+                System.out.println("你真是小聪明，猜对了");
+                break ;
+            }
+            js ++;
+            if (js == 3){
+                System.out.println("你3次都没猜对，该做决定了，继续（Y/y）,我是菜狗不来了（N/n）");
+                char b = sc.next().charAt(0);
+                switch (b){
+                    case 'Y':
+                    case 'y':
+                        js=0;
+                        break ;
+                    case 'N':
+                    case 'n':
+                        break flag;
+                    default:
+                        System.out.println("非法字符，自动退出，你不配玩！");
+                        break flag;
+                }
+            }
+
+        }
+    }
+}
+```
+
+##### 3.2找出最大值
+
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class D3 {
+    public static void main(String[] args) {
+        Random ran = new Random();
+        int[] arr =new int[10];
+        for (int i= 0 ; i<arr.length;i++){
+            arr[i] = ran.nextInt(91)+10;
+        }
+        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
-- 
Gitee


From 554d7a2222bd89db799b0a3e830170b0013373b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E4=BF=8A=E5=93=B2?= <2361967167@qq.com>
Date: Mon, 12 Dec 2022 20:26:38 +0800
Subject: [PATCH 4/4] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...2\346\225\260 \346\225\260\347\273\204.md" | 177 ------------------
 ...04\347\232\204\345\260\217\347\273\223.md" | 156 +++++++++++++++
 2 files changed, 156 insertions(+), 177 deletions(-)
 delete mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"
 create mode 100644 "24 \351\231\210\344\277\212\345\223\262/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md"

diff --git "a/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md" "b/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"
deleted file mode 100644
index 940e21a..0000000
--- "a/24 \351\231\210\344\277\212\345\223\262/20221209 \351\232\217\346\234\272\346\225\260 \346\225\260\347\273\204.md"	
+++ /dev/null
@@ -1,177 +0,0 @@
-##  1、随机数
-
-##### 1.1、生成随机数格式
-
-```java
-Random ran = new Random();//随机数生成
-int a = ran.nextInt(10); //代表[0,10） 0~9,随机数从0开始。
-
-//若要从1~15 则表示为
-int b = ran.nextInt(15)+1;
-```
-
-## 2、数组
-
-##### 2.1、数组的格式
-
- 数组是可存储多个数据的组合
-
-格式如下：
-
-```java
-int[] arr={……}； //数组格式，数组必须初始化
-```
-
-##### 2.2、数组元素访问
-
-①索引从0开始
-
-②格式:
-
-```java
-arr [索引]
-```
-
-③获取数组的长度：
-
-```java
-int a= arr.length;//length为长度
-```
-
-##### 2.3、数组遍历
-
-就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
-
-①从头到尾输出：
-
-```java
-int[] arr={……}
-for(int i=0 ;i<arr.length;i++){
-	System.out.println(arr[i]);
-}
-```
-
-②从头到尾累加：
-
-```java
-int[] arr={……}
-int sum = 0;
-for(int i=0 ;i<arr.length;i++){
-	sum + =arr[i];
-}
-System.out.println(sum);
-```
-
-③获取最大值
-
-最大值获取：从数组的所有元素中找出最大值。
-
-```java
-int[] arr={……};
-int max = arr[0];//取数组第一个数据为初始值
-for(int x=1 ; x<arr.length; x++){
-	if(arr[x] > max){
-	max=arr[x];
-	}
-}
-System.out.println(max);
-```
-
-④元素打乱:
-
-```java
-import java.util.Arrays;
-import java.util.Random;
-
-public class D1 {
-    public static void main(String[] args) {
-        int[] arr = {1, 4, 5, 7, 8, 9};
-        System.out.println(Arrays.toString(arr));//先将数组打印出来
-        //创建随机数
-        Random ran = new Random();
-        //定义两个数据类型，分别赋值不同
-        int a = ran.nextInt(arr.length);
-        int b = ran.nextInt(arr.length);
-        //交换 定义一个新的变量，用于交换
-        int c = arr[a];
-        arr[a] = arr[b];
-        arr[b] = c;
-        //打乱后输出
-        System.out.println(Arrays.toString(arr));
-    }
-}
-```
-
-## 3、作业
-
-##### 3.1、猜数字
-
-```java
-import java.util.Random;
-import java.util.Scanner;
-
-public class D2 {
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        Random ran = new Random();
-        int a = ran.nextInt(90)+10;
-        int js = 0 ;
-        flag:while (true){
-            System.out.println("请输入你所猜的数字（10~99）:");
-            int csz = sc.nextInt();
-            if (csz>a){
-                System.out.println("猜大，重来！");
-            }else if(csz<a){
-                System.out.println("猜小，再来！");
-            }else {
-                System.out.println("你真是小聪明，猜对了");
-                break ;
-            }
-            js ++;
-            if (js == 3){
-                System.out.println("你3次都没猜对，该做决定了，继续（Y/y）,我是菜狗不来了（N/n）");
-                char b = sc.next().charAt(0);
-                switch (b){
-                    case 'Y':
-                    case 'y':
-                        js=0;
-                        break ;
-                    case 'N':
-                    case 'n':
-                        break flag;
-                    default:
-                        System.out.println("非法字符，自动退出，你不配玩！");
-                        break flag;
-                }
-            }
-
-        }
-    }
-}
-```
-
-##### 3.2找出最大值
-
-```java
-import java.util.Arrays;
-import java.util.Random;
-
-public class D3 {
-    public static void main(String[] args) {
-        Random ran = new Random();
-        int[] arr =new int[10];
-        for (int i= 0 ; i<arr.length;i++){
-            arr[i] = ran.nextInt(91)+10;
-        }
-        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/24 \351\231\210\344\277\212\345\223\262/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md" "b/24 \351\231\210\344\277\212\345\223\262/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md"
new file mode 100644
index 0000000..4a5e292
--- /dev/null
+++ "b/24 \351\231\210\344\277\212\345\223\262/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md"	
@@ -0,0 +1,156 @@
+## 数组的小结
+
+1. 数组：一种用来存放多个或一个同一数据类型数据的容器，其实就是一种特殊的变量
+
+2. 数组里存放的每一个数据，称为数组的元素。
+
+3. 为了定位每个元素，程序会给每个元素一个编号，这个编号从0开始，称为索引，注意，索引最大值，只能是长度-1 ===>  length-1
+
+4. 如何得到数组的长度（也就是元素的个数）：
+
+   ```java
+   // 数组名.length
+   int[] ages = {1,2,3};
+   ages.length;
+   // 数组长度什么什么用？
+   //可以用来遍历数组
+   ```
+
+   
+
+5. 数组的赋值，也叫初始化
+
+   1. 静态初始化
+
+      1. 语法： 数据类型[]  数组名 = {元素1，元素2，元素3，……};
+
+      2. 当定义一个数组，同时又明确知道每个元素的值的时候，边定义数组边赋值。
+
+      3. 示例：
+
+         ```java
+         // 定义一个整数类型的数组，存放前三名各个的年龄
+         int[] ages = {18,19,20};
+         ```
+
+         
+
+   2. 动态初始化
+
+      1. 语法：数据类型[]  数组名 = new 数据类型[数组的长度]
+
+      2. 当要定义一个数组，但是只知道长度，却不知道每个元素具体的值的时候。用动态初始化法
+
+      3. 动态初始化，其实是有默认值的 int[]  0 ; double[] 0.0 String[] null    【null 表示啥也没有！】
+
+      4. 示例:
+
+         ```java
+         // 定义一个长度为3的整数类型的数组，得到 0 0 0 这么一个数组
+         int[] a = new int[3];
+         ```
+
+         
+
+6. 怎么使用数组的元素（也就是取值）
+
+   1. 语法： 数组名[索引]
+
+   2. 示例：
+
+      ```java
+      num[1]// 表示取num这个数组中索引为1的那个元素的值，因为索引从0开始，所以这里1表示第2个元素
+      ```
+
+      
+
+7. 数组的遍历：
+
+   1. 将数组每个元素都用到一次
+
+   2. 其实就是从索引0到数组长度-1循环一次，取出每个索引对应的值
+
+   3. 示例，求数组中每个数的总和
+
+      ```java
+      // 普通的标签遍历方法
+      int[] num = {1,2,3};
+      sum = 0;
+      for(int i=0;i<num.length;i++){
+          sum += num[i];
+      }
+      ```
+
+8. 数组常见错误:
+
+   1. 索引越界异常：访问了不存在的索引
+
+      ```java
+      int[] a = {1};
+      sout(a[1]);// 本意是想输出第1个元素，但数组是从0开始的，这里的1表示第2个，
+      // 但数组里并没有第2个，所以会产生索引越界的异常
+      ```
+
+      
+
+   2. 空指针异常：
+
+      ```java
+      int[] b = {11,22};
+      b=null;
+      sout(b[0]);// 异常了
+      ```
+
+      
+
+      作业
+   
+      ~~~java
+      package text.homework;
+      
+      import java.util.Random;
+      
+      public class zy01 {
+          public static void main(String[] args) {
+      //        闽大举行选美比赛，男生参赛，10个女生当评委，
+      //        定义一个数组，存放评分，用随机数模拟打分的过程，
+      //        用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】
+              Random r = new Random();
+              int[] girl = new int[10];
+              //把随机数放入数组
+              for (int i = 0; i < girl.length; i++) {
+                  girl[i] = r.nextInt(100) + 1;
+              }
+              //遍历数组
+              for (int i = 0; i < girl.length; i++) {
+                  System.out.println(girl[i]);
+              }
+              //找到最大值
+              int max = girl[0];
+              for (int i = 1; i < girl.length; i++) {
+                  if(girl[i] > max){
+                      max=girl[i];
+                  }
+              }
+              //找到最小值
+              int min = girl[0];
+              for (int i = 1; i < girl.length; i++) {
+                  if(girl[i] < min){
+                      min=girl[i];
+                  }
+              }
+              //求和
+              int sum = girl[0];
+              for (int i = 1; i < girl.length; i++) {
+                  sum += girl[i];
+              }
+              //取平均
+              int pj = (sum - max - min) / (girl.length - 2);
+              System.out.println("评委打分的平均值为" + pj + "分");
+          }
+      }
+      ~~~
+   
+      
+   
+      
\ No newline at end of file
-- 
Gitee