diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246.md" "b/29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246 - \345\211\257\346\234\254.md"
similarity index 100%
rename from "29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246.md"
rename to "29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246 - \345\211\257\346\234\254.md"
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221202 \345\210\206\346\224\257\347\273\223\346\236\204if\345\222\214switch.md" "b/29 \347\216\213\351\233\257\351\235\231/20221202 \345\210\206\346\224\257\347\273\223\346\236\204if\345\222\214switch.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1f3a9a5cc1a554a5807d12655a8fdf00a297f9f5
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221202 \345\210\206\346\224\257\347\273\223\346\236\204if\345\222\214switch.md"	
@@ -0,0 +1,460 @@
+## 流程控制语句
+
+在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
+
+###  流程控制语句分类(了解)
+
+​	顺序结构
+
+​	分支结构(if, switch)
+
+​	循环结构(for, while, do…while)
+
+### 顺序结构(了解)
+
+顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
+
+顺序结构执行流程图：
+
+![1545615769372](G:\Java仓库\java-base\29 王雯静\images\图片2.png)
+
+###  分支结构之if语句
+
+#### if语句格式1
+
+~~~java
+格式：
+if (关系表达式) {
+    语句体;	
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体
+
+③如果关系表达式的值为false就不执行语句体
+
+④继续执行后面的语句内容
+
+![1545616039363](G:\Java仓库\java-base\29 王雯静\images\图片3.png)
+
+示例：
+
+~~~java
+public class IfDemo {
+	public static void main(String[] args) {
+		System.out.println("开始");
+        
+		// 如果年龄大于18岁, 就可以上网吧
+		int age = 17;
+		
+		if(age >= 18){
+			// int a = 10;
+			System.out.println("可以上网吧");
+		}
+			
+		System.out.println("结束");
+	}
+}
+~~~
+
+####  if语句格式2
+
+~~~java
+格式：
+if (关系表达式) {
+    语句体1;	
+} else {
+    语句体2;	
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体1
+
+③如果关系表达式的值为false就执行语句体2
+
+④继续执行后面的语句内容
+
+![1545616221283](G:\Java仓库\java-base\29 王雯静\images\图片4.png)
+
+示例：奇偶数
+
+​	任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+~~~java
+public class Demo2If {
+	public static void main(String[] args) {
+		// 程序判断一个数, 是奇数还是偶数
+		int num = 9;
+		
+		if(num % 2 == 0){
+			System.out.println("偶数");
+		}else{
+			System.out.println("奇数");
+		}
+	}
+}
+~~~
+
+#### if语句格式3
+
+~~~java
+格式：
+if (关系表达式1) {
+    语句体1;	
+} else if (关系表达式2) {
+    语句体2;	
+} 
+…
+else {
+    语句体n+1;
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式1的值
+
+②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+④…
+
+⑤如果没有任何关系表达式为true，就执行语句体n+1。
+
+![1545616667104](G:\Java仓库\java-base\29 王雯静\images\图片5.png)
+
+示例：
+
+​	定义一个在0~100之间的变量a, 90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油！
+
+~~~java
+public class Demo3If {
+	public static void main(String[] args){
+		int score = 65;
+		if(score >= 90 && score <= 100){
+			System.out.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("成绩有误!");
+		}
+	}
+}
+~~~
+
+#### if语句格式3案例
+
+需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
+
+分析：
+
+​	①小明的考试成绩未知，可以使用键盘录入的方式获取值
+
+​	②由于奖励种类较多，属于多种判断，采用if...else...if格式实现
+
+​	③为每种判断设置对应的条件
+
+​	④为每种判断设置对应的奖励
+
+```java
+import java.util.Scanner;
+public class IfTest02 {
+	public static void main(String[] args){
+		// 1. 使用Scanner录入考试成绩
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入您的成绩:");
+		int score = sc.nextInt();
+		// 2. 判断成绩是否在合法范围内 0~100
+		if(score >=0 && score <= 100){
+			// 合法成绩
+			// 3. 在合法的语句块中判断成绩范围符合哪一个奖励
+			if(score >= 95 && score <= 100){
+				System.out.println("自行车一辆");
+			}else if(score >= 90 && score <= 94){
+				System.out.println("游乐场一次");
+			}else if(score >= 80 && score <= 89){
+				System.out.println("变形金刚一个");
+			}else {
+				System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
+			}
+		}else{
+			// 非法的话, 给出错误提示
+			System.out.println("您的成绩输入有误!");
+		}
+	}
+}
+```
+
+分支语句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;
+}
+}
+}
+
+```
+
+####  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.println("休息日");
+break;
+        default:
+System.out.println("您的输入有误");
+break;
+}
+}
+}
+```
+
+
+
+### 作业：
+
+```java
+import java.util.Scanner;
+
+public class D1 {
+    public static void main(String[] args) {
+        double pay=0;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入乘坐的车型：");
+        String car = sc.next();
+        System.out.println("请输入行车千米数：");
+        double kilometer = sc.nextDouble();
+        double kilo=kilometer-3;
+        switch (car) {
+            case "夏利":
+                if (kilometer > 0 && kilometer <= 3) {
+                    pay+=3;
+                } else {
+                    pay = 3+(kilo*2.1);
+                }
+                break;
+            case "富康":
+                if (kilometer > 0 && kilometer <= 3) {
+                    pay += 4;
+                } else {
+                    pay = 4+(kilo*2.4);
+                }
+                break;
+            case "桑塔纳":
+                if (kilometer > 0 && kilometer <= 3) {
+                    pay += 5;
+                } else {
+                    pay = 5+(kilo*2.7);
+                }
+            break;
+        }
+        System.out.println("需要支付："+pay);
+    }
+}
+```
+
+```java
+import java.util.Scanner;
+
+public class D2 {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入今天的日期：");
+        int year= sc.nextInt();
+        int month=sc.nextInt();
+        int day= sc.nextInt();
+        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=sum+day;
+        }
+        System.out.println(year+"年"+month+"月"+day+"日是本年的第"+sum+"天");
+    }
+}
+```
+
+```java
+import java.util.Scanner;
+
+public class D3 {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入一个字符：");
+        char a=sc.next().charAt(0);
+
+        if (a>='a'&& a<='z' || a>='A'&& a<='Z'){
+            switch (a){
+                case 'a':
+                case 'e':
+                case 'i':
+                case 'o':
+                case 'u':
+                    System.out.println(a+"是小写韵母");
+                    break;
+                case 'A':
+                case 'E':
+                case 'I':
+                case 'O':
+                case 'U':
+                    System.out.println(a+"是大写韵母");
+                    break;
+                case 'b':
+                case 'c':
+                case 'd':
+                case 'g':
+                case 'h':
+                case 'j':
+                case 'k':
+                case 'l':
+                case 'm':
+                case 'n':
+                case 'p':
+                case 'q':
+                case 'r':
+                case 's':
+                case 't':
+                case 'v':
+                case 'w':
+                case 'x':
+                case 'y':
+                case 'z':
+                    System.out.println(a+"是小写声母");
+                    break;
+                default:
+                    System.out.println(a+"是大写声母");
+            }
+
+        }else{
+            System.out.println("输入的字符不是字母。");
+        }
+
+    }
+
+
+
+```
\ No newline at end of file
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221206 \345\276\252\347\216\257\350\257\255\345\217\245for while do-while.md" "b/29 \347\216\213\351\233\257\351\235\231/20221206 \345\276\252\347\216\257\350\257\255\345\217\245for while do-while.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b84cceab233423676e320cf96d76e154b4aed0e5
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221206 \345\276\252\347\216\257\350\257\255\345\217\245for while do-while.md"	
@@ -0,0 +1,388 @@
+# for 循环
+
+##### 循环：
+
+循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环 体    语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循 环，否 则循环将一直执行下去，形 成死循环。
+
+#### for循环的格式：
+
+```
+for(初始化语句;条件判断语句;条件控制语句){
+   循环体语句;
+}
+```
+
+##### 格式解释：
+
+初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样 
+
+ 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去 
+
+循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情 
+
+条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+##### 执行流程：
+
+①执行初始化语句 
+
+ ②执行条件判断语句，看其结果是true还是false
+
+ 如果是false，循环结束 如果是true，继续执行 
+
+③执行循环体语句
+
+ ④执行条件控制语句
+
+ ⑤回到②继续
+
+#### 举例1（循环输出1~5）：
+
+```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);
+}
+}
+}
+```
+
+#### 举例2 （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);
+}
+}
+
+```
+
+###### 本题要点：
+
+ 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量 
+
+求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+
+#### 举例3（求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);
+}
+}
+```
+
+#### 举例4（求1~100之间的所有偶数和比奇数和多多少）
+
+```java
+public class ForTest04 {
+public static void main(String[] args) {
+    int jsum = 0;
+    int osum = 0;
+    for(int = 1; i <= 100; i++)
+        if{
+            jsum += i;
+        }else{
+            osum += i;
+        }
+    System.out.println(osum-jsum);
+}
+}
+    
+```
+
+##### 什么是水仙花数？
+
+ 水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数 
+
+例如 153 3*3*3 + 5*5*5 + 1*1*1 = 153 
+
+#### 举例5 .1（水仙花数）
+
+```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);
+}
+}
+}
+}
+
+```
+
+###### 思路：
+
+1获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环 获取
+
+ 2. 获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
+
+#### 5.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;
+int 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();
+}
+}
+}
+}
+}
+```
+
+###### 本题要点：
+
+ 今后如果需求带有统计xxx，请先想到计数器变量 
+
+计数器变量定义的位置，必须在循环外部
+
+# while循环
+
+##### 格式：
+
+```
+初始化语句;
+while (条件判断语句) {
+循环体语句;
+条件控制语句;
+}
+```
+
+#### while循环执行流程：
+
+ ①执行初始化语句
+
+ ②执行条件判断语句，看其结果是true还是false 
+
+如果是false，循环结束 如果是true，继续执行
+
+③执行循环体语句 
+
+④执行条件控制语句 
+
+⑤回到②继续
+
+#### 举例1（循环5次HelloWord）
+
+```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++;
+}
+}
+}
+```
+
+#### 举例2（珠穆朗玛峰）
+
+需求：世界最高山峰是珠穆朗玛峰(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 + "次");
+}
+}
+```
+
+# do-while循环
+
+##### 格式：
+
+```
+初始化语句;
+do {
+循环体语句;
+条件控制语句;
+}while(条件判断语句);
+
+```
+
+#### 执行流程：
+
+ ① 执行初始化语句
+
+ ② 执行循环体语句 
+
+③ 执行条件控制语句
+
+ ④ 执行条件判断语句，看其结果是true还是false 
+
+如果是false，循环结束
+
+ 如果是true，继续执行
+
+ ⑤ 回到②继续
+
+#### 举例1（循环5次HelloWord）
+
+```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循环结束 后，该变量还可以继续使用
+
+# 死循环
+
+##### 格式：
+
+```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/29 \347\216\213\351\233\257\351\235\231/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\357\274\210break conttiue\357\274\211\351\232\217\346\234\272\346\225\260\357\274\210random\357\274\211\346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md" "b/29 \347\216\213\351\233\257\351\235\231/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\357\274\210break conttiue\357\274\211\351\232\217\346\234\272\346\225\260\357\274\210random\357\274\211\346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0a141e68b0c468d121a3fa9507bc4c63fdca5931
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221208 \350\267\263\350\275\254\350\257\255\345\217\245\357\274\210break conttiue\357\274\211\351\232\217\346\234\272\346\225\260\357\274\210random\357\274\211\346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"	
@@ -0,0 +1,783 @@
+# 跳转控制语句
+
+**跳转控制语句（break）**
+
+跳出循环，结束循环
+
+**跳转控制语句（continue）**
+
+跳过本次循环，继续下次循环
+
+*注意： continue只能在循环中进行使用！*
+
+**例如：**
+
+```java
+public class Demo1Continue {
+/*
+continue : 跳过某次循环体内容的执行
+注意：使用是基于条件控制, 在循环内部使用.
+需求: 模拟电梯上行的过程 1-24层, 4层不停.
+*/
+public static void main(String[] args){
+for(int i = 1; i <= 24; i++){
+if(i == 4){
+continue;
+}
+System.out.println(i + "层到了~");
+}
+}
+}
+
+public class Demo2Break {
+/*
+break : 终止循环体内容的执行
+注意：使用是基于条件控制的
+break语句只能在循环和switch中进行使用.
+需求: 模拟20岁工作到80岁, 60岁退休.
+*/
+public static void main(String[] args){
+for(int i = 20; i <= 80; i++){
+if(i == 60){
+break; // 结束整个循环
+}
+System.out.println(i + "岁正在上班");
+}
+}
+}
+
+import java.util.Scanner;
+public class Test {
+/*
+需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
+步骤:
+1. 不明确用户操作几次, 使用死循环包裹业务逻辑
+2. 匹配到0的时候，使用break结束循环死循环
+*/
+public static void main (String[] args){
+lo:while(true){
+System.out.println("请输入您要查看的星期数:");
+System.out.println("(如无需继续查看,请输入0退出程序)");
+// 1. 键盘录入星期数据，使用变量接收
+Scanner sc = new Scanner(System.in);
+int week = sc.nextInt();
+// 2. 多情况判断，采用switch语句实现
+switch(week){
+// 3. 在不同的case中，输出对应的减肥计划
+case 0:
+System.out.println("感谢您的使用");
+break lo;
+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;
+}
+}
+}
+}
+```
+
+## 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);
+}
+}
+}
+```
+
+### Random练习-猜数字
+
+需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？当猜错的时候根据不同情况给出相应的提示
+
+A. 如果猜的数字比真实数字大，提示你猜的数据大了
+
+B. 如果猜的数字比真实数字小，提示你猜的数据小了
+
+C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
+
+```java
+import java.util.Scanner;
+import java.util.Random;
+public class Test {
+/*
+需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+当猜错的时候根据不同情况给出相应的提示
+如果猜的数字比真实数字大，提示你猜的数据大了
+如果猜的数字比真实数字小，提示你猜的数据小了
+如果猜的数字与真实数字相等，提示恭喜你猜中了
+1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+2. 使用Random产生一个1-100之间的数, 作为要猜的数
+3. 键盘录入用户猜的的数据
+4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死
+循环包裹
+6. 猜对之后, break结束.
+*/
+public static void main(String[] args){
+// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+Random r = new Random();
+Scanner sc = new Scanner(System.in);
+// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
+int randomNum = r.nextInt(100) + 1;
+// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用
+while(true)死循环包裹
+while(true){
+// 3. 键盘录入用户猜的的数据
+System.out.println("请输入您猜的数据:");
+int num = sc.nextInt();
+// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+if(num > randomNum){
+System.out.println("猜大了");
+}else if(num < randomNum){
+System.out.println("猜小了");
+}else{
+// 6. 猜对之后, break结束.
+System.out.println("恭喜,猜中了");
+break;
+}
+}
+System.out.println("感谢您的使用");
+}
+}
+```
+
+## 数组
+
+数组介绍
+
+​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
+
+### 数组的定义格式
+
+#### 第一种格式
+
+​ 数据类型[] 数组名
+
+```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:代表数组的长度
+    
+    ```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);
+    
+    }
+    }
+    ```
+
+## 数组元素访问
+
+#### 什么是索引
+
+​ 每一个存储到数组的元素，都会自动的拥有一个编号，从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]);
+    }
+}
+```
+
+## 数组的静态初始化
+
+#### 什么是静态初始化
+
+​ 在创建数组时，直接将元素确定
+
+#### 静态初始化格式
+
+* 完整版格式
+  
+      数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+
+* 简化版格式
+  
+      数据类型[] 数组名 = {元素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
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+          System.out.println(arr[3]);
+      }
+  }
+  ```
+  
+  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+  
+  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+* 解决方案
+  
+  将错误的索引修改为正确的索引范围即可！
+
+#### 空指针异常
+
+* 出现原因
+  
+  ```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 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+* 解决方案
+  
+  给数组一个真正的堆内存空间引用即可！
+
+### 数组遍历
+
+* 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+  
+  ```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]);
+          }
+      }
+  }
+  ```
+
+### 数组获取最大值
+
+* 最大值获取：从数组的所有元素中找出最大值。
+
+* 实现思路：
+  
+  * 定义变量，保存数组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);
+      }
+  }
+  ```
+
+### 数组元素求和
+
+* 需求：键盘录入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);
+  
+      }
+  }
+  ```
+
+### 数组基本查找
+
+* 需求：
+  
+              已知一个数组 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);
+      }
+  }
+  ```
+
+### 评委打分
+
+* 需求：在编程竞赛中，有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
+import java.util.Random;
+import java.util.Scanner;
+
+public class D5 {
+    public static void main(String[] args) {
+        Random ran = new Random();
+        int num = ran.nextInt(100)+1;
+        Scanner sc = new Scanner(System.in);
+        while (true){
+            System.out.println("输入你猜的数字：");
+            int num1 = sc.nextInt();
+            if(num >num1){
+                System.out.println("猜小了");
+
+
+            }else if(num <num1) {
+                System.out.println("猜大了");
+
+            }else{
+                System.out.println("猜对了");
+                break;
+            }
+        }
+    }
+}
+```
+
+比大小：
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class f1 {
+    public static void main(String[] args) {
+        int count=0;
+        Random r=new Random();
+        Scanner sc=new Scanner(System.in);
+        int num= r.nextInt(100)+1;
+        om:while (true) {
+            System.out.println("请输入你猜的数：");
+            int a = sc.nextInt();
+            count++;
+            if (a>num){
+                System.out.println("大了");
+            }else if(a<num){
+                System.out.println("小了");
+            }else{
+                System.out.println("恭喜你，猜对了。");
+                break;
+            }
+            if (count==3){
+                System.out.println("已猜三次，如想再猜请输入Y/y，如退出请输入N/n");
+                char b=sc.next().charAt(0);
+                switch (b){
+                    case 'Y':
+                    case 'y':
+                       count=0;
+                       continue om;
+                    case 'N':
+                    case 'n':
+                    default:
+                        break om;
+                }
+            }
+        }
+    }
+}
+```
diff --git "a/29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md" "b/29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3ed516897d1f7254da966c5e2eb0b7814d6fecd8
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"	
@@ -0,0 +1,526 @@
+## 数组
+
+数组介绍
+
+​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
+
+### 数组的定义格式
+
+#### 第一种格式
+
+​ 数据类型[] 数组名
+
+    int[] arr;        
+    double[] arr;      
+    char[] arr;
+
+### 第二种格式
+
+​ 数据类型 数组名[]
+
+    int arr[];
+    double arr[];
+    char arr[];
+
+## 数组的动态初始化
+
+#### 什么是动态初始化
+
+​ 数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+#### 动态初始化格式
+
+    数据类型[] 数组名 = new 数据类型[数组长度];
+    
+    
+    
+    
+        int[] arr = new int[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);
+    
+    }
+    }
+    ```
+
+## 数组元素访问
+
+#### 什么是索引
+
+​ 每一个存储到数组的元素，都会自动的拥有一个编号，从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]);
+    }
+}
+```
+
+## 数组的静态初始化
+
+#### 什么是静态初始化
+
+​ 在创建数组时，直接将元素确定
+
+#### 静态初始化格式
+
+* 完整版格式
+  
+      数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+
+* 简化版格式
+  
+      数据类型[] 数组名 = {元素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
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+          System.out.println(arr[3]);
+      }
+  }
+  ```
+  
+  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+  
+  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+* 解决方案
+  
+  将错误的索引修改为正确的索引范围即可！
+
+#### 空指针异常
+
+* 出现原因
+  
+  ```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 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+* 解决方案
+  
+  给数组一个真正的堆内存空间引用即可！
+
+### 数组遍历
+
+* 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+  
+  ```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]);
+          }
+      }
+  }
+  ```
+
+### 数组获取最大值
+
+* 最大值获取：从数组的所有元素中找出最大值。
+
+* 实现思路：
+  
+  * 定义变量，保存数组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);
+      }
+  }
+  ```
+
+### 数组元素求和
+
+* 需求：键盘录入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);
+  
+      }
+  }
+  ```
+
+### 数组基本查找
+
+* 需求：
+  
+              已知一个数组 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);
+      }
+  }
+  ```
+
+### 评委打分
+
+* 需求：在编程竞赛中，有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
+public class D1 {
+        public static void main(String[] args) {
+            int[] score = new int [10];
+            int max = score[0];
+            int min = score[0];
+            int sum = 0;
+            Random s = new Random();
+            for (int i = 0;i<score.length;i++ ){
+                score[i] = s.nextInt(100)+1;
+                System.out.println("评分" + s[i ]);
+                sun += score[i];
+                if (max<score[i]){
+                    max = score[i];
+                }else if (min>score[i]){
+                    min = score[i];
+                }
+            }
+            System.out.println("最后得分是"+(((sun-max-min)*0.1)/10));
+
+
+        }
+    }
+
+```
diff --git "a/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2072.png" "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2072.png"
new file mode 100644
index 0000000000000000000000000000000000000000..54a5b64dade4a61fee0e2ff91effa4b5be4def2c
Binary files /dev/null and "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2072.png" differ
diff --git "a/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2073.png" "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2073.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b17ad14d51deb7103046585e0ab0206177976631
Binary files /dev/null and "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2073.png" differ
diff --git "a/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2074.png" "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2074.png"
new file mode 100644
index 0000000000000000000000000000000000000000..17494d812df010f09713db004bf7983c95c69c02
Binary files /dev/null and "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2074.png" differ
diff --git "a/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2075.png" "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2075.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b7835a46e9950ccf8d0429ede987c4cff03b3b02
Binary files /dev/null and "b/29 \347\216\213\351\233\257\351\235\231/images/\345\233\276\347\211\2075.png" differ