diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221124 Java\346\246\202\350\277\260\344\270\216\347\254\254\344\270\200\344\270\252\346\274\224\347\244\272\347\250\213\345\272\217.md" "b/07 \345\206\257\345\273\272\347\250\213/20221124 Java\346\246\202\350\277\260\344\270\216\347\254\254\344\270\200\344\270\252\346\274\224\347\244\272\347\250\213\345\272\217.md"
new file mode 100644
index 0000000000000000000000000000000000000000..480bcf45de825a60cd9bce09e6a4621c471085fa
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221124 Java\346\246\202\350\277\260\344\270\216\347\254\254\344\270\200\344\270\252\346\274\224\347\244\272\347\250\213\345\272\217.md"	
@@ -0,0 +1,159 @@
+---
+typora-root-url: Java笔记图片补充
+---
+
+# 1. Java概述
+
+## 1.1 Java语言发展史
+
+语言:人与人交流沟通的表达方式
+
+计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言
+
+Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言
+
+Java之父:詹姆斯·高斯林(James Gosling)
+
+2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/1.1.png)
+
+## 1.2 Java语言跨平台原理
+
+Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机(JVM)对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/1.2.png)
+
+## 1.3 JRE和JDK
+
+JVM(Java Virtual Machine)，Java虚拟机
+
+JRE(Java Runtime Environment)，Java运行环境，包含了JVM和Java的核心类库(Java API) JDK(Java Development Kit)称为Java开发工具，包含了JRE和开发工具
+
+总结:我们只需安装JDK即可，它包含了java的运行环境和虚拟机。
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/1.3.png)
+
+## 1.4 JDK的下载和安装
+
+### 1.4.1 下载
+
+通过官方网站获取JDK
+
+[http://www.oracle.com](http://www.oracle.com/)
+
+**注意**:针对不同的操作系统，需要下载对应版本的JDK。
+
+### 1.4.2 安装
+
+傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下，例如:E:\develop。
+
+**注意**:安装路径不要包含中文或者空格等特殊字符(使用纯英文目录)。
+
+### 1.4.3 JDK的安装目录介绍
+
+| 目录名称 |                             说明                             |
+| :------: | :----------------------------------------------------------: |
+|   bin    | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
+|   conf   |              该路径下存放了JDK的相关配置文件。               |
+| include  |             该路径下存放了一些平台特定的头文件。             |
+|  jmods   |                该路径下存放了JDK的各种模块。                 |
+|  legal   |             该路径下存放了JDK各模块的授权文档。              |
+|   lib    |            该路径下存放了JDK工具的一些补充JAR包。            |
+
+# 2. 第一个演示程序
+
+## 2.1 常用DOS命令
+
+在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。
+
+1、打开命令行窗口的方式:win + r打开运行窗口，输入cmd，回车。
+
+2、常用命令及其作用
+
+|      操作       |               说明                |
+| :-------------: | :-------------------------------: |
+|    盘符名称:    | 盘符切换。E:回车，表示切换到E盘。 |
+|       dir       |      查看当前路径下的内容。       |
+|     cd 目录     |    进入单级目录。cd itterence     |
+|      cd .       |        回退到上一级目录。         |
+| cd 目录1\目录2… | 进入多级目录。cd itterence\JavaSE |
+|      cd \       |         回退到盘符目录。          |
+|       cls       |              清屏。               |
+|      exit       |       退出命令提示符窗口。        |
+
+## 2.2 Path环境变量的配置
+
+### 2.2.1 为什么配置环境变量
+
+开发Java程序，需要使用JDK提供的开发工具(比如javac.exe、java.exe等命令)，而这些工具在JDK的安装目录的 bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。
+
+### 2.2.2 配置环境变量步骤
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/2.2.2.png)
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/2.2.2-2.png)
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/2.2.2-3.png)
+
+**如果命令提示符窗口是配合环境变量前打开的,需要关闭该窗口,重新打开一个窗口测试**
+
+## 2.3 HelloWorld案例
+
+HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。
+
+### 2.3.1 Java程序开发运行流程
+
+开发Java程序，需要三个步骤:编写程序，编译程序，运行程序。
+
+### 2.3.2 HelloWorld案例的编写
+
+1、新建文本文档文件，修改名称为HelloWorld.java。
+
+2、用记事本打开HelloWorld.java文件，输写程序内容。
+
+```java
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("HelloWorld");
+    }
+}
+```
+
+### 2.3.3 HelloWorld案例的编译和运行
+
+存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。
+
+> 编译:javac 文件名.java
+>
+> 范例:javac HelloWorld.java
+>
+> 执行:java 类名
+>
+> 范例:java HelloWorld
+
+## 2.4 HelloWorld案例常见问题(理解)
+
+### 2.4.1 BUG
+
+在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug(漏洞)。
+
+### 2.4.2 BUG的解决
+
+1、具备识别BUG的能力:多看
+
+2、具备分析BUG的能力:多思考，多查资料
+
+3、具备解决BUG的能力:多尝试，多总结
+
+### 2.4.3 HelloWorld案例常见问题
+
+1、非法字符问题。Java中的符号都是英文格式的。
+
+2、大小写问题。Java语言对大小写敏感(区分大小写)。
+
+3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
+
+4、编译命令后的java文件名需要带文件后缀.java
+
+5、运行命令后的class文件名(类名)不带文件后缀.class …
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/\346\210\221\347\232\204Java\347\254\224\350\256\260.md" "b/07 \345\206\257\345\273\272\347\250\213/20221125 Java\347\232\204\345\237\272\347\241\200\350\257\255\346\263\225\344\270\216\350\277\220\347\256\227\347\254\246.md"
similarity index 31%
rename from "07 \345\206\257\345\273\272\347\250\213/\346\210\221\347\232\204Java\347\254\224\350\256\260.md"
rename to "07 \345\206\257\345\273\272\347\250\213/20221125 Java\347\232\204\345\237\272\347\241\200\350\257\255\346\263\225\344\270\216\350\277\220\347\256\227\347\254\246.md"
index 4130fab6e0611979d52be3374d967bbdc6ac480a..5329f89e58753affa1bad9db46fbc915cefbfb8b 100644
--- "a/07 \345\206\257\345\273\272\347\250\213/\346\210\221\347\232\204Java\347\254\224\350\256\260.md"	
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221125 Java\347\232\204\345\237\272\347\241\200\350\257\255\346\263\225\344\270\216\350\277\220\347\256\227\347\254\246.md"	
@@ -1,163 +1,7 @@
 ---
-typora-root-url: Java笔记图片补充
+typora-root-url: D:\java仓库\java-base\07 冯建程\Java笔记图片补充
 ---
 
-# 1. Java概述
-
-## 1.1 Java语言发展史
-
-语言:人与人交流沟通的表达方式
-
-计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言
-
-Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言
-
-Java之父:詹姆斯·高斯林(James Gosling)
-
-2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com
-
-![](/1.1.png)
-
-## 1.2 Java语言跨平台原理
-
-Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机(JVM)对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。
-
-![](/1.2.png)
-
-## 1.3 JRE和JDK
-
-JVM(Java Virtual Machine)，Java虚拟机
-
-JRE(Java Runtime Environment)，Java运行环境，包含了JVM和Java的核心类库(Java API) JDK(Java Development Kit)称为Java开发工具，包含了JRE和开发工具
-
-总结:我们只需安装JDK即可，它包含了java的运行环境和虚拟机。
-
-![](/1.3.png)
-
-## 1.4 JDK的下载和安装
-
-### 1.4.1 下载
-
-通过官方网站获取JDK
-
-[http://www.oracle.com](http://www.oracle.com/)
-
-**注意**:针对不同的操作系统，需要下载对应版本的JDK。
-
-### 1.4.2 安装
-
-傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下，例如:E:\develop。
-
-**注意**:安装路径不要包含中文或者空格等特殊字符(使用纯英文目录)。
-
-### 1.4.3 JDK的安装目录介绍
-
-| 目录名称 |                             说明                             |
-| :------: | :----------------------------------------------------------: |
-|   bin    | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
-|   conf   |              该路径下存放了JDK的相关配置文件。               |
-| include  |             该路径下存放了一些平台特定的头文件。             |
-|  jmods   |                该路径下存放了JDK的各种模块。                 |
-|  legal   |             该路径下存放了JDK各模块的授权文档。              |
-|   lib    |            该路径下存放了JDK工具的一些补充JAR包。            |
-
-# 2. 第一个演示程序
-
-## 2.1 常用DOS命令
-
-在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。
-
-1、打开命令行窗口的方式:win + r打开运行窗口，输入cmd，回车。
-
-2、常用命令及其作用
-
-|      操作       |               说明                |
-| :-------------: | :-------------------------------: |
-|    盘符名称:    | 盘符切换。E:回车，表示切换到E盘。 |
-|       dir       |      查看当前路径下的内容。       |
-|     cd 目录     |    进入单级目录。cd itterence     |
-|      cd .       |        回退到上一级目录。         |
-| cd 目录1\目录2… | 进入多级目录。cd itterence\JavaSE |
-|      cd \       |         回退到盘符目录。          |
-|       cls       |              清屏。               |
-|      exit       |       退出命令提示符窗口。        |
-
-## 2.2 Path环境变量的配置
-
-### 2.2.1 为什么配置环境变量
-
-开发Java程序，需要使用JDK提供的开发工具(比如javac.exe、java.exe等命令)，而这些工具在JDK的安装目录的 bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。
-
-### 2.2.2 配置环境变量步骤
-
-![](/2.2.2.png)
-
-![](/2.2.2-2.png)
-
-![](/2.2.2-3.png)
-
-**如果命令提示符窗口是配合环境变量前打开的,需要关闭该窗口,重新打开一个窗口测试**
-
-## 2.3 HelloWorld案例
-
-HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。
-
-### 2.3.1 Java程序开发运行流程
-
-开发Java程序，需要三个步骤:编写程序，编译程序，运行程序。
-
-### 2.3.2 HelloWorld案例的编写
-
-1、新建文本文档文件，修改名称为HelloWorld.java。
-
-2、用记事本打开HelloWorld.java文件，输写程序内容。
-
-```java
-public class HelloWorld {
-    public static void main(String[] args) {
-        System.out.println("HelloWorld");
-    }
-}
-```
-
-### 2.3.3 HelloWorld案例的编译和运行
-
-存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。
-
-> 编译:javac 文件名.java
->
-> 范例:javac HelloWorld.java
->
-> 执行:java 类名
->
-> 范例:java HelloWorld
-
-## 2.4 HelloWorld案例常见问题(理解)
-
-### 2.4.1 BUG
-
-在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug(漏洞)。
-
-### 2.4.2 BUG的解决
-
-1、具备识别BUG的能力:多看
-
-2、具备分析BUG的能力:多思考，多查资料
-
-3、具备解决BUG的能力:多尝试，多总结
-
-### 2.4.3 HelloWorld案例常见问题
-
-1、非法字符问题。Java中的符号都是英文格式的。
-
-2、大小写问题。Java语言对大小写敏感(区分大小写)。
-
-3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
-
-4、编译命令后的java文件名需要带文件后缀.java
-
-5、运行命令后的class文件名(类名)不带文件后缀.class …
-
 # 3. java基础语法
 
 ## 3.1 注释
@@ -267,11 +111,11 @@ Java中的基本数据类型:
 
 从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
 
-![3.5.1变量的定义](/3.5.1变量的定义.png)
+![3.5.1变量的定义](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/3.5.1变量的定义.png)
 
 变量的定义格式:
 
-![3.5.1变量的定义格式](/3.5.1变量的定义格式.png)
+![3.5.1变量的定义格式](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/3.5.1变量的定义格式.png)
 
 > 数据类型 变量名 = 初始化值; // 声明变量并赋值
 > int age = 18;
@@ -287,7 +131,7 @@ Java中的基本数据类型:
 
 还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。
 
-```java
+```Java
 int a = 10, b = 20; // 定义int类型的变量a和b，中间使用逗号隔开
 System.out.println(a);
 System.out.println(b);
@@ -342,7 +186,7 @@ Java中标识符的命名约定:
 
 例如:
 
-```java
+```Java
  double num = 10; // 将int类型的10直接赋值给double类型
  System.out.println(num); // 输出10.0
 ```
@@ -355,7 +199,7 @@ Java中标识符的命名约定:
 
 例如:
 
-```java
+```Java
 double num1 = 5.5;
 int num2 = (int) num1; // 将double类型的num1强制转换为int类型
 System.out.println(num2); // 输出5(小数位直接舍弃)
@@ -368,7 +212,7 @@ System.out.println(num2); // 输出5(小数位直接舍弃)
 1. char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a’对应97
 
 ```java
- int a = 'a';
+int a = 'a';
  System.out.println(a); // 将输出97
 ```
 
@@ -624,7 +468,6 @@ System.out.println((i > j) | (i< k)); //false | true,输出true
 System.out.println((i < j) | (i< k)); //true | true,输出true
 System.out.println("--------");
 
-
 //^ “异或”，相同为false，不同为true
 System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
 System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
@@ -720,1806 +563,3 @@ public class OperatorTest02 {
 }
 ```
 
-# 5. 数据输入
-
-我们可以通过 Scanner 类来获取用户的输入。使用步骤如下:
-
-1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
-
-> import java.util.Scanner;
-
-2、创建Scanner对象。
-
-> Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变
-
-3、接收数据
-
-> int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
-
-示例:
-
-```java
-import java.util.Scanner;
-
-public class ScannerDemo {
-	public static void main(String[] args) { //创建对象
-		Scanner sc = new Scanner(System.in); //接收数据
-		int x = sc.nextInt();
-		//输出数据
-        System.out.println("x:" + x);
-    }
-}
-```
-
-改写三个和尚案例，数据使用键盘录入。
-
-```java
-import java.util.Scanner;
-
-public class ScannerTest {
-	public static void main(String[] args) {
-		//身高未知，采用键盘录入实现。首先导包，然后创建对象。
-		Scanner sc = new Scanner(System.in);
-
-		//键盘录入三个身高分别赋值给三个变量。
-		System.out.println("请输入第一个和尚的身高：");
-		int height1 = sc.nextInt();
-
-		System.out.println("请输入第二个和尚的身高：");
-		int height2 = sc.nextInt();
-
-		System.out.println("请输入第三个和尚的身高：");
-		int height3 = sc.nextInt();
-
-		//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
-		int tempHeight = height1 > height2 ? height1 : height2;
-
-		//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
-		int maxHeight = tempHeight > height3 ? tempHeight : height3;
-
-		//输出结果。
-		System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
-	}
-}
-```
-
-# 6. 流程控制语句
-
-在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
-
-## 6.1 流程控制语句分类
-
-顺序结构
-
-分支结构(if, switch)
-
-循环结构(for, while, do…while)
-
-## 6.2 顺序结构
-
-顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
-
-顺序结构执行流程图:
-
-![6.2](/6.2.png)
-
-## 6.3 分支结构之if语句
-
-### 6.3.1 if语句格式1
-
-> 格式:
->
-> if (关系表达式) {
->
-> 语句体;
->
-> }
-
-执行流程:
-
-1首先计算关系表达式的值
-
-2如果关系表达式的值为true就执行语句体
-
-3如果关系表达式的值为false就不执行语句体
-
-4继续执行后面的语句内容
-
-![6.3.1 if 语句格式1](/6.3.1 if 语句格式1.png)
-
-示例:
-
-```java
-public class IfDemo {
-	public static void main(String[] args) {
-		System.out.println("开始");
-
-		//定义两个变量
-		int a = 10;
-		int b = 20;
-
-		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
-		if(a == b) {
-			System.out.println("a等于b");
-		}
-
-		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
-		int c = 10;
-		if(a == c) {
-			System.out.println("a等于c");
-		}
-
-		System.out.println("结束");
-	}
-}
-```
-
-### 6.3.2 if语句格式2
-
-> 格式:
->
-> if (关系表达式) {
->
-> 语句体1;
->
-> } else {
->
-> 语句体2;
->
-> }
-
-执行流程:
-
-1. 首先计算关系表达式的值
-
-2. 如果关系表达式的值为true就执行语句体1
-
-3. 如果关系表达式的值为false就执行语句体2
-
-4. 继续执行后面的语句内容
-
-![6.3.2 if 语句格式2](/6.3.2 if 语句格式2.png)
-
-示例:
-
-```java
-public class IfDemo02 {
-	public static void main(String[] args) {
-		System.out.println("开始");
-
-		//定义两个变量
-		int a = 10;
-		int b = 20;
-		b = 5;
-
-		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，
-		//如果不是，在控制台输出：a的值不大于b
-		if(a > b) {
-			System.out.println("a的值大于b");
-		} else {
-			System.out.println("a的值不大于b");
-		}
-
-		System.out.println("结束");
-	}
-}
-```
-
-if语句案例:奇偶数
-
-需求:任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
-
-分析:
-
-为了体现任意给出一个整数，采用键盘录入一个数据
-
-判断整数是偶数还是奇数要分两种情况进行判断，使用if…else结构
-
-判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
-
-根据判定情况，在控制台输出对应的内容
-
-```java
- 
-import java.util.Scanner;
-
-public class IfTest01 {
-	public static void main(String[] args) {
-		//为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
-		Scanner sc = new Scanner(System.in);
-
-		System.out.println("请输入一个整数：");
-		int number = sc.nextInt();
-
-		//判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
-		//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
-		//根据判定情况，在控制台输出对应的内容
-		if(number%2 == 0) {
-			System.out.println(number + "是偶数");
-		} else {
-			System.out.println(number + "是奇数");
-		}
-
-	}
-}
-```
-
-### 6.3.3 if语句格式3
-
-> 格式:
->
-> if (关系表达式1) {
->
-> 语句体1;
->
-> } else if (关系表达式2) {
->
-> 语句体2;
->
-> }
->
-> …
->
-> else {
->
-> 语句体n+1;
->
-> }
-
-执行流程:
-
-1. 首先计算关系表达式1的值
-
-2. 如果值为true就执行语句体1;如果值为false就计算关系表达式2的值
-
-3. 如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
-
-4. …
-
-5. 如果没有任何关系表达式为true，就执行语句体n+1。
-
-![6.3.3 if 语句格式3](/6.3.3 if 语句格式3.png)
-
-示例:
-
-键盘录入一个星期数(1,2,…7)，输出对应的星期一，星期二，…星期日
-
-```java
-import java.util.Scanner;
-
-public class IfDemo03 {
-	public static void main(String[] args) {
-		System.out.println("开始");
-
-		//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
-		Scanner sc = new Scanner(System.in);
-
-		System.out.println("请输入一个星期数(1-7)：");
-		int week = sc.nextInt();
-
-		if(week == 1) {
-			System.out.println("星期一");
-		} else if(week == 2) {
-			System.out.println("星期二");
-		} else if(week == 3) {
-			System.out.println("星期三");
-		} else if(week == 4) {
-			System.out.println("星期四");
-		} else if(week == 5) {
-			System.out.println("星期五");
-		} else if(week == 6) {
-			System.out.println("星期六");
-		} else {
-			System.out.println("星期日");
-		}
-
-		System.out.println("结束");
-	}
-}
-```
-
-if语句格式3案例:
-
-需求:小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
-
-分析:
-
-小明的考试成绩未知，可以使用键盘录入的方式获取值
-
-由于奖励种类较多，属于多种判断，采用if…else…if格式实现
-
-为每种判断设置对应的条件
-
-为每种判断设置对应的奖励
-
-```java
-import java.util.Scanner;
-
-public class IfTest02 {
-	public static void main(String[] args) {
-		//小明的考试成绩未知，可以使用键盘录入的方式获取值
-		Scanner sc = new Scanner(System.in);
-
-		System.out.println("请输入一个分数：");
-		int score = sc.nextInt();
-
-		//由于奖励种类较多，属于多种判断，采用if...else...if格式实现
-		//为每种判断设置对应的条件
-		//为每种判断设置对应的奖励
-
-		//数据测试：正确数据，边界数据，错误数据
-		if(score>100 || score<0) {
-			System.out.println("你输入的分数有误");
-		} else 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("胖揍一顿");
-		}
-	}
-}
-```
-
-# 7. switch语句
-
-## 7.1 switch语句结构
-
-格式
-
-```java
-switch (表达式) {
-	case 1:
-		语句体1;
-		break;
-	case 2:
-		语句体2;
-		break;
-	...
-	default:
-		语句体n+1;
-		break;
-}
-```
-
-格式说明：
-
-- 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
-
-- case：后面跟的是要和表达式进行比较的值。
-
-- break：表示中断，结束的意思，用来结束switch语句。
-
-- default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
-
-执行流程：
-
-- 首先计算出表达式的值
-
-- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
-
-- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
-
-![7.1](/7.1.png)
-
-## 7.2 switch语句练习-春夏秋冬（应用）
-
-- 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
-
-- 运行结果：
-
-```java
-春：3、4、5
-夏：6、7、8
-秋：9、10、11
-冬：1、2、12
-```
-
-- 示例代码：
-
-```java
-import java.util.Scanner;
-
-public class SwitchTest {
-	public static void main(String[] args) {
-		//键盘录入月份数据，使用变量接收
-		Scanner sc = new Scanner(System.in);
-
-		System.out.println("请输入一个月份：");
-		int month = sc.nextInt();
-
-		//多情况判断，这里采用switch语句实现
-		//在每种情况中，完成输出对应的季节
-		/*
-		switch(month) {
-			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;
-			case 8:
-				System.out.println("夏季");
-				break;
-			case 9:
-				System.out.println("秋季");
-				break;
-			case 10:
-				System.out.println("秋季");
-				break;
-			case 11:
-				System.out.println("秋季");
-				break;
-			case 12:
-				System.out.println("冬季");
-				break;
-			default:
-				System.out.println("你输入的月份有误");
-				//break;
-		}
-		*/
-
-		//case穿透
-		switch(month) {
-			case 1:
-			case 2:
-			case 12:
-				System.out.println("冬季");
-				break;
-			case 3:
-			case 4:
-			case 5:
-				System.out.println("春季");
-				break;
-			case 6:
-			case 7:
-			case 8:
-				System.out.println("夏季");
-				break;
-			case 9:
-			case 10:
-			case 11:
-				System.out.println("秋季");
-				break;
-			default:
-				System.out.println("你输入的月份有误");
-		}
-	}
-}
-```
-
-- 注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。
-
-# 8. for循环
-
-## 8.1 for循环结构（掌握）
-
-- 循环：
-
-  循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
-
-- for循环格式：
-
-```java
-for (初始化语句;条件判断语句;条件控制语句) {
-	循环体语句;
-}
-```
-
-格式解释：
-
-- 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
-
-- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
-
-- 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
-
-- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
-
-执行流程：
-
-①执行初始化语句
-
-②执行条件判断语句，看其结果是true还是false
-
-如果是false，循环结束
-
-如果是true，继续执行
-
-③执行循环体语句
-
-④执行条件控制语句
-
-⑤回到②继续
-
-```java
-public class ForDemo {
-	public static void main(String[] args) {
-		//需求：在控制台输出5次"HelloWorld"
-		System.out.println("HelloWorld");
-		System.out.println("HelloWorld");
-		System.out.println("HelloWorld");
-		System.out.println("HelloWorld");
-		System.out.println("HelloWorld");
-		System.out.println("--------");
-
-		//用循环改进
-		for(int i=1; i<=5; i++) {
-			System.out.println("HelloWorld");
-		}
-
-	}
-}
-```
-
-## 8.2 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);
-		}
-
-	}
-}
-```
-
-## 8.3 for循环练习-求和
-
-- 需求：求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);
-	}
-}
-```
-
-- 本题要点：
-- 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
-  
-- 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
-
-## 8.4 for循环练习-求偶数和
-
-- 需求：求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);
-	}
-}
-```
-
-## 8.5 for循环练习-水仙花
-
-- 需求：在控制台输出所有的“水仙花数”
-
-- 解释：什么是水仙花数？
-
-水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
-
-例如153 3*3*3 + 5*5*5 + 1*1*1 = 153
-
-- 思路：
-
-1. 获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
-
-2. 获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
-
-- 示例代码
-
-```java
-public class ForTest04 {
-	public static void main(String[] args) {
-		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
-		/*
-		for(int i=100; i<=999; i++) {
-
-		}
-		*/
-		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);
-			}
-		}
-	}
-}
-```
-
-## 8.6 for循环练习-统计水仙花数个数
-
-- 需求：统计“水仙花数”一共有多少个，并在控制台输出个数
-
-- 示例代码：
-
-```java
-public class ForTest05 {
-	public static void main(String[] args) {
-		//定义变量count，用于保存“水仙花数”的数量，初始值为0
-		int count = 0;
-
-		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
-		for(int i=100; i<1000; i++) {
-			//在计算之前获取三位数中每个位上的值
-			int ge = i%10;
-			int shi = i/10%10;
-			int bai = i/10/10%10;
-
-			//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
-			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
-				count++;
-			}
-		}
-
-		//打印输出最终结果
-		System.out.println("水仙花共有：" + count + "个");
-	}
-}
-```
-
-- 本题要点：
-- 今后如果需求带有统计xxx，请先想到计数器变量
-  
-- 计数器变量定义的位置，必须在循环外部
-
-# 9. while循环
-
-## 9.1 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++;
-		}
-
-	}
-}
-```
-
-## 9.2 while循环练习-珠穆朗玛峰
-
-- 需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
-
-- 示例代码：
-
-```java
-public class WhileTest {
-	public static void main(String[] args) {
-		//定义一个计数器，初始值为0
-		int count = 0;
-
-		//定义纸张厚度
-		double paper = 0.1;
-
-		//定义珠穆朗玛峰的高度
-		int zf = 8844430;
-
-		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
-		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
-		while(paper <= zf) {
-			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
-			paper *= 2;
-
-			//在循环中执行累加，对应折叠了多少次
-			count++;
-		}
-
-		//打印计数器的值
-		System.out.println("需要折叠：" + count + "次");
-	}
-}
-```
-
-# 10. 循环细节
-
-## 10.1 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);
-
-	}
-}
-```
-
-## 10.2 三种循环的区别
-
-- 三种循环的区别
-
-1. for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
-
-2. do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
-
-- for循环和while的区别
-
-1. 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
-
-2. 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
-
-- 死循环（无限循环）的三种格式
-
-1. for(;; ){}
-
-2. while(true){}
-
-3. do {} while(true);
-
-## 10.3 跳转控制语句
-
-- 跳转控制语句（break）
-  - 跳出循环，结束循环
-  
-- 跳转控制语句（continue）
-  - 跳过本次循环，继续下次循环
-  
-- 注意： continue只能在循环中进行使用！
-
-## 10.4 循环嵌套
-
-- 循环嵌套概述：在循环中，继续定义循环
-
-- 示例代码：
-
-```java
-public class ForForDemo {
-	public static void main(String[] args) {
-		for(int hour=0; hour<24; hour++) {
-			for(int minute=0; minute<60; minute++) {
-				System.out.println(hour + "时" + minute + "分");
-			}
-			System.out.println("--------");
-		}
-	}
-}
-```
-
-- 理解：
-- 请反复理解这句话（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）
-- 结论：
-- 外循环执行一次，内循环执行一圈。
-
-# 11. Random
-
-## 11.1 Random产生随机数
-
-- 概述：
-  - Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
-    - API后续课程详细讲解，现在可以简单理解为Java已经写好的代码
-
-使用步骤：
-
-1. 导入包
-
-   import java.util.Random;
-
-1. 创建对象
-
-   Random r = new Random();
-
-2. 产生随机数
-
-   int num = r.nextInt(10);
-
-   解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
-
-- 示例代码：
-
-```java
-import java.util.Random;
-
-public class RandomDemo {
-	public static void main(String[] args) {
-		//创建对象
-		Random r = new Random();
-
-		//用循环获取10个随机数
-		for(int i=0; i<10; i++) {
-			//获取随机数
-			int number = r.nextInt(10);
-			System.out.println("number:" + number);
-		}
-
-		//需求：获取一个1-100之间的随机数
-		int x = r.nextInt(100) + 1;
-		System.out.println(x);
-	}
-}
-```
-
-## 11.2 Random练习-猜数字
-
-- 需求：
-
-程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
-
-当猜错的时候根据不同情况给出相应的提示
-
-A. 如果猜的数字比真实数字大，提示你猜的数据大了
-
-B. 如果猜的数字比真实数字小，提示你猜的数据小了
-
-C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
-
-- 示例代码：
-
-```java
-import java.util.Random;
-import java.util.Scanner;
-
-public class RandomTest {
-	public static void main(String[] args) {
-		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
-		Random r = new Random();
-		int number = r.nextInt(100) + 1;
-
-		while(true) {
-			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
-			Scanner sc = new Scanner(System.in);
-
-			System.out.println("请输入你要猜的数字：");
-			int guessNumber = sc.nextInt();
-
-			//比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
-			if(guessNumber > number) {
-				System.out.println("你猜的数字" + guessNumber + "大了");
-			} else if(guessNumber < number) {
-				System.out.println("你猜的数字" + guessNumber + "小了");
-			} else {
-				System.out.println("恭喜你猜中了");
-				break;
-			}
-		}
-	}
-}
-```
-
-# 12. IDEA开发工具
-
-参见：IDEA工具安装详解.pdf
-[IDEA工具安装详解.pdf](https://download.csdn.net/download/qq_39997939/85072242)
-
-# 13. 数组
-
-### 13.2.1 第一种
-
- 数据类型[] 数组名
-
- 示例：
-
-```java
-int[] arr;        
-double[] arr;      
-char[] arr;
-```
-
-定义了一个int类型的数组,数组名是arr
-
-### 13.2.2 第二种(不推荐)
-
- 数据类型 数组名[]
-
- 示例：
-
-```java
-int arr[];
-double arr[];
-char arr[];
-```
-
-定义了一个int类型的变量,变量名是arr数组
-
-## 13.3 数组动态初始化
-
-数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
-
-### 13.3.2 动态初始化格式
-
-```java
-数据类型[] 数组名 = new 数据类型[数组长度];
-```
-
-```java
-int[] arr = new int[3];
-```
-
-### 13.3.3动态初始化格式详解
-
-- 等号左边：
-  - int:数组的数据类型
-  - []:代表这是一个数组
-  - arr:代表数组的名称
-
-- 等号右边：
-  - new:为数组开辟内存空间
-  - int:数组的数据类型
-  - []:代表这是一个数组
-  - 3:代表数组的长度
-
-## 13.4 数组元素访问
-
-### 13.4.1 什么是索引
-
- 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
-
- 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
-
-### 13.4.2 访问数组元素格式
-
-```java
-数组名[索引];
-```
-
-### 13.4.3 示例代码
-
-```java
-public class ArrayDemo {
-    public static void main(String[] args) {
-        int[] arr = new int[3];
-
-        //输出数组名
-        System.out.println(arr); //[I@880ec60
-
-        //输出数组中的元素
-        System.out.println(arr[0]);
-        System.out.println(arr[1]);
-        System.out.println(arr[2]);
-    }
-}
-```
-
-## 13.5 内存分配
-
-### 13.5.1 内存概述
-
-内存是计算机中的重要原件，临时存储区域，作用是运行程序。
-
- 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
-
- 必须放进内存中才能运行，运行完毕后会清空内存。
-
- Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
-
-### 13.5.2 java中的内存分配
-
-- 目前我们只需要记住两个内存，分别是：栈内存和堆内存
-
-|  区域名称  |                            作用                            |
-| :--------: | :--------------------------------------------------------: |
-|   寄存器   |                给CPU使用，和我们开发无关。                 |
-| 本地方法栈 |     JVM在使用操作系统功能的时候使用，和我们开发无关。      |
-|   方法区   |                 存储可以运行的class文件。                  |
-|   堆内存   |      存储对象或者数组，new来创建的，都存储在堆内存。       |
-|   方法栈   | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
-
-## 13.6 单个数组的内存图
-
-![](/13.6.png)
-
-## 13.7 多个数组的内存图
-
-![](/13.7.png)
-
-## 13.8 多个数组指向相同内存图
-
-![](/13.8.png)
-
-## 13.9 数组静态初始化
-
-### 13.9.1 什么是静态初始化
-
- 在创建数组时，直接将元素确定
-
-### 13.9.2 静态初始化格式
-
-- 完整版格式
-
-```java
-数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
-```
-
-- 简化版格式
-
-```java
-数据类型[] 数组名 = {元素1,元素2,...};
-```
-
-### 13.9.3 示例代码
-
-```java
-public class ArrayDemo {
-    public static void main(String[] args) {
-        //定义数组
-        int[] arr = {1, 2, 3};
-
-        //输出数组名
-        System.out.println(arr);
-
-        //输出数组中的元素
-        System.out.println(arr[0]);
-        System.out.println(arr[1]);
-        System.out.println(arr[2]);
-    }
-}
-```
-
-## 13.10 数组操作的两个常见小问题
-
-### 13.10.1 索引越界异常
-
-- 出现原因
-
-```java
-public class ArrayDemo {
-    public static void main(String[] args) {
-        int[] arr = new int[3];
-		System.out.println(arr[3]);
-    }
-}
-```
-
-数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
-
-程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
-
-- 解决方案
-
-
-将错误的索引修改为正确的索引范围即可！
-
-
-### 13.10.2 空指针异常
-
-- 出现原因
-
-```java
-public class ArrayDemo {
-    public static void main(String[] args) {
-        int[] arr = new int[3];
-		//把null赋值给数组
-        arr = null;
-        System.out.println(arr[0]);
-    }
-}
-```
-
-arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
-
-- 解决方案
-
-
-给数组一个真正的堆内存空间引用即可！
-
-
-## 13.11 数组遍历
-
-- 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
-
-```java
-public class ArrayTest01 {
-	public static void main(String[] args) {
-		int[] arr = { 1, 2, 3, 4, 5 };
-		System.out.println(arr[0]);
-		System.out.println(arr[1]);
-		System.out.println(arr[2]);
-		System.out.println(arr[3]);
-		System.out.println(arr[4]);
-	}
-}
-```
-
-以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。
-
-```java
-public class ArrayTest01 {
-    public static void main(String[] args) {
-        //定义数组
-        int[] arr = {11, 22, 33, 44, 55};
-
-        //使用通用的遍历格式
-        for(int x=0; x<arr.length; x++) {
-            System.out.println(arr[x]);
-        }
-    }
-}
-```
-
-## 13.12 数组最值
-
-- 最大值获取：从数组的所有元素中找出最大值。
-
-- 实现思路：
-  - 定义变量，保存数组0索引上的元素
-  - 遍历数组，获取出数组中的每个元素
-  - 将遍历到的元素和保存数组0索引上值的变量进行比较
-  - 如果数组元素的值大于了变量的值，变量记录住新的值
-  - 数组循环遍历结束，变量保存的就是数组中的最大值
-
-- 代码实现：
-
-```java
-public class ArrayTest02 {
-    public static void main(String[] args) {
-        //定义数组
-        int[] arr = {12, 45, 98, 73, 60};
-
-        //定义一个变量，用于保存最大值
-        //取数组中第一个数据作为变量的初始值
-        int max = arr[0];
-
-        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
-        for(int x=1; x<arr.length; x++) {
-            if(arr[x] > max) {
-                max = arr[x];
-            }
-        }
-
-        //循环结束后打印变量的值
-        System.out.println("max:" + max);
-
-    }
-}
-```
-
-## 13.13 作业：评委打分
-
-### 13.13.1 案例需求
-
-闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】。
-
-### 13.13.2 代码实现
-
-```java
-/*
-    思路：
-        1:定义一个数组，用动态初始化完成数组元素的初始化，长度为10
-        2:键盘录入评委分数
-        3:由于是10个评委打分，所以，接收评委分数的操作，用循环改进
-        4:定义方法实现获取数组中的最高分(数组最大值)，调用方法
-        5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法
-        6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
-        7:按照计算规则进行计算得到平均分
-        8:输出平均分
- */
-public class Test10 {
-    public static void main(String[] args) {
-        //定义一个数组，用动态初始化完成数组元素的初始化，长度为10
-        int[] arr = new int[10];
-
-        //键盘录入评委分数
-        Scanner sc = new Scanner(System.in);
-
-        //由于是10个评委打分，所以，接收评委分数的操作，用循环改进
-        for(int x=0; x<arr.length; x++) {
-            System.out.println("请输入第" + (x + 1) + "个评委的打分：");
-            arr[x] = sc.nextInt();
-        }
-
-        //printArray(arr);
-
-        //定义方法实现获取数组中的最高分(数组最大值)，调用方法
-        int max = getMax(arr);
-
-        //定义方法实现获取数组中的最低分(数组最小值) ，调用方法
-        int min = getMin(arr);
-
-        //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
-        int sum = getSum(arr);
-
-        //按照计算规则进行计算得到平均分
-        int avg = (sum - max - min) / (arr.length - 2);
-
-        //输出平均分
-        System.out.println("选手的最终得分是：" + avg);
-
-    }
-
-    /*
-        两个明确：
-            返回值类型：int
-            参数：int[] arr
-     */
-    public static int getSum(int[] arr) {
-        int sum = 0;
-
-        for(int x=0; x<arr.length; x++) {
-            sum += arr[x];
-        }
-
-        return sum;
-    }
-
-    /*
-        两个明确：
-            返回值类型：int
-            参数：int[] arr
-     */
-    public static int getMin(int[] arr) {
-        int min = arr[0];
-
-        for(int x=1; x<arr.length; x++) {
-            if(arr[x] < min) {
-                min = arr[x];
-            }
-        }
-
-        return min;
-    }
-
-    /*
-        两个明确：
-            返回值类型：int
-            参数：int[] arr
-     */
-    public static int getMax(int[] arr) {
-        int max = arr[0];
-
-        for(int x=1; x<arr.length; x++) {
-            if(arr[x] > max) {
-                max = arr[x];
-            }
-        }
-
-        return max;
-    }
-
-    //遍历数组
-    public static void printArray(int[] arr) {
-        System.out.print("[");
-
-        for (int x = 0; x < arr.length; x++) {
-            if (x == arr.length - 1) {
-                System.out.print(arr[x]);
-            } else {
-                System.out.print(arr[x] + ", ");
-            }
-        }
-
-        System.out.println("]");
-    }
-}
-```
-
-# 14. 方法概述
-
-## 14.1 方法的概念
-
-方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
-
-![](/14.1.png)
-
-![](/14.1.1.png)
-
-- 注意：
-  - 方法必须先创建才可以使用，该过程成为方法定义
-  - 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
-
-## 14.2. 方法的定义和调用
-
-### 14.2.1 无参数方法定义和调用
-
-- 定义格式：
-
-```java
-public static void 方法名 (   ) {
-	// 方法体;
-}
-```
-
-- 范例：
-
-```java
-public static void method (    ) {
-	// 方法体;
-}
-```
-
-- 调用格式：
-
-```Java
-方法名();
-```
-
-- 范例：
-
-```java
-method();
-```
-
-- 注意：
-
-   方法必须先定义，后调用，否则程序将报错
-
-### 14.2.2 方法调用过程图解
-
-![](/14.2.2.png)
-
-- 总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。
-
-### 14.2.3 无参数方法的练习
-
-- 需求：设计一个方法用于打印两个数中的较大数
-- 思路：
-  - ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
-  - ②方法中定义两个变量，用于保存两个数字
-  - ③使用分支语句分两种情况对两个数字的大小关系进行处理
-  - ④在main()方法中调用定义好的方法
-
-- 代码：
-
-```java
-public class MethodTest {
-    public static void main(String[] args) {
-        //在main()方法中调用定义好的方法
-        getMax();
-    }
-
-    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
-    public static void getMax() {
-        //方法中定义两个变量，用于保存两个数字
-        int a = 10;
-        int b = 20;
-
-        //使用分支语句分两种情况对两个数字的大小关系进行处理
-        if(a > b) {
-            System.out.println(a);
-        } else {
-            System.out.println(b);
-        }
-    }
-}
-```
-
-## 14.3 带参数方法定义和调用
-
-### 14.3.1 带参数方法定义和调用
-
-- 定义格式：
-
-  参数：由数据类型和变量名组成 - 数据类型 变量名
-
-  参数范例：int a
-
-```java
-public static void 方法名 (参数1) {
-	方法体;
-}
-
-public static void 方法名 (参数1, 参数2, 参数3...) {
-	方法体;
-}
-```
-
-- 范例：
-
-```java
-public static void isEvenNumber(int number){
-    ...
-}
-public static void getMax(int num1, int num2){
-    ...
-}
-```
-
-- 注意：
-
-```java
-方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
-
-方法定义时，多个参数之间使用逗号( ，)分隔
-```
-
-- 调用格式：
-
-```java
-方法名(参数)；
-
-方法名(参数1,参数2);
-```
-
-- 范例：
-
-```java
-isEvenNumber(10);
-
-getMax(10,20);
-```
-
-- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
-
-### 14.3.2 形参和实参
-
-1. 形参：方法定义中的参数
-
- 等同于变量定义格式，例如：int number
-
-1. 实参：方法调用中的参数
-
- 等同于使用变量或常量，例如： 10 number
-
-### 14.3.3 带参数方法练习
-
-- 需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }
-- 思路：
-  - ①定义一个方法用于打印两个数字中的较大数，例如getMax()
-  - ②为方法定义两个参数，用于接收两个数字
-  - ③使用分支语句分两种情况对两个数字的大小关系进行处理
-  - ④在main()方法中调用定义好的方法（使用常量）
-  - ⑤在main()方法中调用定义好的方法（使用变量）
-
-- 代码：
-
-```java
-public class MethodTest {
-    public static void main(String[] args) {
-        //在main()方法中调用定义好的方法（使用常量）
-        getMax(10,20);
-        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
-        //getMax(30);
-        //getMax(10.0,20.0);
-
-        //在main()方法中调用定义好的方法（使用变量）
-        int a = 10;
-        int b = 20;
-        getMax(a, b);
-    }
-
-    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
-    //为方法定义两个参数，用于接收两个数字
-    public static void getMax(int a, int b) {
-        //使用分支语句分两种情况对两个数字的大小关系进行处理
-        if(a > b) {
-            System.out.println(a);
-        } else {
-            System.out.println(b);
-        }
-    }
-}
-```
-
-## 14.4 带返回值方法的定义和调用
-
-### 14.4.1 带返回值方法定义和调用
-
-- 定义格式
-
-```java
-public static 数据类型 方法名 ( 参数 ) { 
-	return 数据 ;
-}
-```
-
-- 范例
-
-```java
-public static boolean isEvenNumber( int number ) {           
-	return true ;
-}
-public static int getMax( int a, int b ) {
-	return  100 ;
-}
-```
-
-- 注意：
-  - 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
-
-- 调用格式
-
-```java
-方法名 ( 参数 ) ;
-数据类型 变量名 = 方法名 ( 参数 ) ;
-```
-
-- 范例
-
-```java
-isEvenNumber ( 5 ) ;
-boolean  flag =  isEvenNumber ( 5 ); 
-```
-
-- 注意：
-  - 方法的返回值通常会使用变量接收，否则该返回值将无意义
-
-### 14.4.2 带返回值方法练习
-
-- 需求：设计一个方法可以获取两个数的较大值，数据来自于参数
-- 思路：
-  - ①定义一个方法，用于获取两个数字中的较大数
-  - ②使用分支语句分两种情况对两个数字的大小关系进行处理
-  - ③根据题设分别设置两种情况下对应的返回结果
-  - ④在main()方法中调用定义好的方法并使用变量保存
-  - ⑤在main()方法中调用定义好的方法并直接打印结果
-
-- 代码：
-
-```java
-public class MethodTest {
-    public static void main(String[] args) {
-        //在main()方法中调用定义好的方法并使用变量保存
-        int result = getMax(10,20);
-        System.out.println(result);
-
-        //在main()方法中调用定义好的方法并直接打印结果
-        System.out.println(getMax(10,20));
-    }
-
-    //定义一个方法，用于获取两个数字中的较大数
-    public static int getMax(int a, int b) {
-        //使用分支语句分两种情况对两个数字的大小关系进行处理
-        //根据题设分别设置两种情况下对应的返回结果
-        if(a > b) {
-            return a;
-        } else {
-            return b;
-        }
-    }
-}
-```
-
-## 14.5 方法的注意事项
-
-### 14.5.1 方法的注意事项
-
-- 方法不能嵌套定义
-  - 示例代码：
-
-```java
-public class MethodDemo {
-    public static void main(String[] args) {
-
-    }
-
-    public static void methodOne() {
-		public static void methodTwo() {
-       		// 这里会引发编译错误!!!
-    	}
-    }
-}
-```
-
-- void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
-- 示例代码：
-
-```java
-public class MethodDemo {
-    public static void main(String[] args) {
-
-    }
-    public static void methodTwo() {
-        //return 100; 编译错误，因为没有具体返回值类型
-        return;	
-        //System.out.println(100); return语句后面不能跟数据或代码
-    }
-}
-```
-
-### 14.5.2 方法的通用格式
-
-- 格式：
-
-```java
-public static 返回值类型 方法名(参数) {
-   方法体; 
-   return 数据 ;
-}
-```
-
-- 解释：
-
-  - public static 修饰符，目前先记住这个格式
-
-    返回值类型 方法操作完毕之后返回的数据的数据类型
-
-     如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
-
-    方法名 调用方法时候使用的标识
-
-    参数 由数据类型和变量名组成，多个参数之间用逗号隔开
-
-    方法体 完成功能的代码块
-
-    return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
-
-- 定义方法时，要做到两个明确
-  - 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
-  - 明确参数：主要是明确参数的类型和数量
-
-- 调用方法时的注意：
-  - void类型的方法，直接调用即可
-  - 非void类型的方法，推荐用变量接收调用
-
-## 14.6 作业
-
-### 14.6.1 案例需求
-
-定义一函数，用于求2个数中的较大数，并将其返回，这2个数字在主函数中由用户输入
-
-### 12.6.2 代码实现
-
-```java
-package com;
-public class Test {
-    public static void main(String[] args) {
-        System.out.println("max = " + max(5, 8));
-    }
-    public static int max(int num1, int num2) {
-        return num1 > num2 ? num1 : num2;
-    }
-}
-```
-
-### 14.6.3 案例需求
-
-在主函数中从键盘接收X, Y , Z3个数，编写函数计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3
-
-### 14.6.4 代码实现
-
-```java
-import java.util.Scanner;
-public class Main{
-	public static void main(String args[]){
-		Scanner in = new Scanner(System.in);
-		int a = in.nextInt();
-		int b = in.nextInt();
-		int c = in.nextInt();
-		float sum;
-		double aver;
-		sum=a+b+c;
-		aver=sum/3.0;
-		System.out.printf("sum=%.1f\n",sum);
-		System.out.print("average="+aver);
-	}
-}
-```
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221202 Java\347\232\204\346\225\260\346\215\256\350\276\223\345\205\245\344\270\216switch\350\257\255\345\217\245.md" "b/07 \345\206\257\345\273\272\347\250\213/20221202 Java\347\232\204\346\225\260\346\215\256\350\276\223\345\205\245\344\270\216switch\350\257\255\345\217\245.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e127edc923ee0a4ca413d7385fe901a6fd27eb18
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221202 Java\347\232\204\346\225\260\346\215\256\350\276\223\345\205\245\344\270\216switch\350\257\255\345\217\245.md"	
@@ -0,0 +1,489 @@
+---
+typora-root-url: D:\java仓库\java-base\07 冯建程\Java笔记图片补充
+---
+
+# 5. 数据输入
+
+我们可以通过 Scanner 类来获取用户的输入。使用步骤如下:
+
+1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
+
+> import java.util.Scanner;
+
+2、创建Scanner对象。
+
+> Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变
+
+3、接收数据
+
+> int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
+
+示例:
+
+```java
+import java.util.Scanner;
+
+public class ScannerDemo {
+	public static void main(String[] args) { //创建对象
+		Scanner sc = new Scanner(System.in); //接收数据
+		int x = sc.nextInt();
+		//输出数据
+        System.out.println("x:" + x);
+    }
+}
+```
+
+改写三个和尚案例，数据使用键盘录入。
+
+```java
+import java.util.Scanner;
+
+public class ScannerTest {
+	public static void main(String[] args) {
+		//身高未知，采用键盘录入实现。首先导包，然后创建对象。
+		Scanner sc = new Scanner(System.in);
+
+		//键盘录入三个身高分别赋值给三个变量。
+		System.out.println("请输入第一个和尚的身高：");
+		int height1 = sc.nextInt();
+
+		System.out.println("请输入第二个和尚的身高：");
+		int height2 = sc.nextInt();
+
+		System.out.println("请输入第三个和尚的身高：");
+		int height3 = sc.nextInt();
+
+		//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
+		int tempHeight = height1 > height2 ? height1 : height2;
+
+		//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
+		int maxHeight = tempHeight > height3 ? tempHeight : height3;
+
+		//输出结果。
+		System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
+	}
+}
+```
+
+# 6. 流程控制语句
+
+在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
+
+## 6.1 流程控制语句分类
+
+顺序结构
+
+分支结构(if, switch)
+
+循环结构(for, while, do…while)
+
+## 6.2 顺序结构
+
+顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
+
+顺序结构执行流程图:
+
+![6.2](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/6.2.png)
+
+## 6.3 分支结构之if语句
+
+### 6.3.1 if语句格式1
+
+> 格式:
+>
+> if (关系表达式) {
+>
+> 语句体;
+>
+> }
+
+执行流程:
+
+1首先计算关系表达式的值
+
+2如果关系表达式的值为true就执行语句体
+
+3如果关系表达式的值为false就不执行语句体
+
+4继续执行后面的语句内容
+
+![6.3.1 if 语句格式1](/6.3.1 if 语句格式1.png)
+
+示例:
+
+```Java
+public class IfDemo {
+	public static void main(String[] args) {
+		System.out.println("开始");
+
+		//定义两个变量
+		int a = 10;
+		int b = 20;
+
+		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
+		if(a == b) {
+			System.out.println("a等于b");
+		}
+
+		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
+		int c = 10;
+		if(a == c) {
+			System.out.println("a等于c");
+		}
+
+		System.out.println("结束");
+	}
+}
+```
+
+### 6.3.2 if语句格式2
+
+> 格式:
+>
+> if (关系表达式) {
+>
+> 语句体1;
+>
+> } else {
+>
+> 语句体2;
+>
+> }
+
+执行流程:
+
+1. 首先计算关系表达式的值
+
+2. 如果关系表达式的值为true就执行语句体1
+
+3. 如果关系表达式的值为false就执行语句体2
+
+4. 继续执行后面的语句内容
+
+![6.3.2 if 语句格式2](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/6.3.2 if 语句格式2.png)
+
+示例:
+
+```Java
+public class IfDemo02 {
+	public static void main(String[] args) {
+		System.out.println("开始");
+
+		//定义两个变量
+		int a = 10;
+		int b = 20;
+		b = 5;
+
+		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，
+		//如果不是，在控制台输出：a的值不大于b
+		if(a > b) {
+			System.out.println("a的值大于b");
+		} else {
+			System.out.println("a的值不大于b");
+		}
+
+		System.out.println("结束");
+	}
+}
+```
+
+if语句案例:奇偶数
+
+需求:任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+分析:
+
+为了体现任意给出一个整数，采用键盘录入一个数据
+
+判断整数是偶数还是奇数要分两种情况进行判断，使用if…else结构
+
+判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
+
+根据判定情况，在控制台输出对应的内容
+
+```java
+import java.util.Scanner;
+
+public class IfTest01 {
+	public static void main(String[] args) {
+		//为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
+		Scanner sc = new Scanner(System.in);
+
+		System.out.println("请输入一个整数：");
+		int number = sc.nextInt();
+
+		//判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
+		//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
+		//根据判定情况，在控制台输出对应的内容
+		if(number%2 == 0) {
+			System.out.println(number + "是偶数");
+		} else {
+			System.out.println(number + "是奇数");
+		}
+
+	}
+}
+```
+
+### 6.3.3 if语句格式3
+
+> 格式:
+>
+> if (关系表达式1) {
+>
+> 语句体1;
+>
+> } else if (关系表达式2) {
+>
+> 语句体2;
+>
+> }
+>
+> …
+>
+> else {
+>
+> 语句体n+1;
+>
+> }
+
+执行流程:
+
+1. 首先计算关系表达式1的值
+
+2. 如果值为true就执行语句体1;如果值为false就计算关系表达式2的值
+
+3. 如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
+
+4. …
+
+5. 如果没有任何关系表达式为true，就执行语句体n+1。
+
+![6.3.3 if 语句格式3](/6.3.3 if 语句格式3.png)
+
+示例:
+
+键盘录入一个星期数(1,2,…7)，输出对应的星期一，星期二，…星期日
+
+```java
+import java.util.Scanner;
+
+public class IfDemo03 {
+	public static void main(String[] args) {
+		System.out.println("开始");
+
+		//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
+		Scanner sc = new Scanner(System.in);
+
+		System.out.println("请输入一个星期数(1-7)：");
+		int week = sc.nextInt();
+
+		if(week == 1) {
+			System.out.println("星期一");
+		} else if(week == 2) {
+			System.out.println("星期二");
+		} else if(week == 3) {
+			System.out.println("星期三");
+		} else if(week == 4) {
+			System.out.println("星期四");
+		} else if(week == 5) {
+			System.out.println("星期五");
+		} else if(week == 6) {
+			System.out.println("星期六");
+		} else {
+			System.out.println("星期日");
+		}
+
+		System.out.println("结束");
+	}
+}
+```
+
+if语句格式3案例:
+
+需求:小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
+
+分析:
+
+小明的考试成绩未知，可以使用键盘录入的方式获取值
+
+由于奖励种类较多，属于多种判断，采用if…else…if格式实现
+
+为每种判断设置对应的条件
+
+为每种判断设置对应的奖励
+
+```Java
+import java.util.Scanner;
+
+public class IfTest02 {
+	public static void main(String[] args) {
+		//小明的考试成绩未知，可以使用键盘录入的方式获取值
+		Scanner sc = new Scanner(System.in);
+
+		System.out.println("请输入一个分数：");
+		int score = sc.nextInt();
+
+		//由于奖励种类较多，属于多种判断，采用if...else...if格式实现
+		//为每种判断设置对应的条件
+		//为每种判断设置对应的奖励
+
+		//数据测试：正确数据，边界数据，错误数据
+		if(score>100 || score<0) {
+			System.out.println("你输入的分数有误");
+		} else 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("胖揍一顿");
+		}
+	}
+}
+```
+
+# 7. switch语句
+
+## 7.1 switch语句结构
+
+格式
+
+```java
+switch (表达式) {
+	case 1:
+		语句体1;
+		break;
+	case 2:
+		语句体2;
+		break;
+	...
+	default:
+		语句体n+1;
+		break;
+}
+```
+
+格式说明：
+
+- 表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
+
+- case：后面跟的是要和表达式进行比较的值。
+
+- break：表示中断，结束的意思，用来结束switch语句。
+
+- default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
+
+执行流程：
+
+- 首先计算出表达式的值
+
+- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
+
+- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+![7.1](/7.1.png)
+
+## 7.2 switch语句练习-春夏秋冬（应用）
+
+- 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
+
+- 运行结果：
+
+```
+春：3、4、5
+夏：6、7、8
+秋：9、10、11
+冬：1、2、12
+```
+
+- 示例代码：
+
+```java
+import java.util.Scanner;
+
+public class SwitchTest {
+	public static void main(String[] args) {
+		//键盘录入月份数据，使用变量接收
+		Scanner sc = new Scanner(System.in);
+
+		System.out.println("请输入一个月份：");
+		int month = sc.nextInt();
+
+		//多情况判断，这里采用switch语句实现
+		//在每种情况中，完成输出对应的季节
+		/*
+		switch(month) {
+			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;
+			case 8:
+				System.out.println("夏季");
+				break;
+			case 9:
+				System.out.println("秋季");
+				break;
+			case 10:
+				System.out.println("秋季");
+				break;
+			case 11:
+				System.out.println("秋季");
+				break;
+			case 12:
+				System.out.println("冬季");
+				break;
+			default:
+				System.out.println("你输入的月份有误");
+				//break;
+		}
+		*/
+
+		//case穿透
+		switch(month) {
+			case 1:
+			case 2:
+			case 12:
+				System.out.println("冬季");
+				break;
+			case 3:
+			case 4:
+			case 5:
+				System.out.println("春季");
+				break;
+			case 6:
+			case 7:
+			case 8:
+				System.out.println("夏季");
+				break;
+			case 9:
+			case 10:
+			case 11:
+				System.out.println("秋季");
+				break;
+			default:
+				System.out.println("你输入的月份有误");
+		}
+	}
+}
+```
+
+- 注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221206 Java\347\232\204for.shile.do\345\276\252\347\216\257.md" "b/07 \345\206\257\345\273\272\347\250\213/20221206 Java\347\232\204for.shile.do\345\276\252\347\216\257.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7d05026f46b30e1597ba0afa9211d7d11a171642
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221206 Java\347\232\204for.shile.do\345\276\252\347\216\257.md"	
@@ -0,0 +1,423 @@
+# 8. for循环
+
+## 8.1 for循环结构（掌握）
+
+- 循环：
+
+  循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
+
+- for循环格式：
+
+```
+for (初始化语句;条件判断语句;条件控制语句) {
+	循环体语句;
+}
+```
+
+格式解释：
+
+- 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+
+- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+
+- 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+
+- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+执行流程：
+
+①执行初始化语句
+
+②执行条件判断语句，看其结果是true还是false
+
+如果是false，循环结束
+
+如果是true，继续执行
+
+③执行循环体语句
+
+④执行条件控制语句
+
+⑤回到②继续
+
+```java
+public class ForDemo {
+	public static void main(String[] args) {
+		//需求：在控制台输出5次"HelloWorld"
+		System.out.println("HelloWorld");
+		System.out.println("HelloWorld");
+		System.out.println("HelloWorld");
+		System.out.println("HelloWorld");
+		System.out.println("HelloWorld");
+		System.out.println("--------");
+
+		//用循环改进
+		for(int i=1; i<=5; i++) {
+			System.out.println("HelloWorld");
+		}
+
+	}
+}
+```
+
+## 8.2 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);
+		}
+
+	}
+}
+```
+
+## 8.3 for循环练习-求和
+
+- 需求：求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);
+	}
+}
+```
+
+- 本题要点：
+- 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
+
+- 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+
+## 8.4 for循环练习-求偶数和
+
+- 需求：求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);
+	}
+}
+```
+
+## 8.5 for循环练习-水仙花
+
+- 需求：在控制台输出所有的“水仙花数”
+
+- 解释：什么是水仙花数？
+
+水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
+
+例如153 3*3*3 + 5*5*5 + 1*1*1 = 153
+
+- 思路：
+
+1. 获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
+
+2. 获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
+
+- 示例代码
+
+```java
+public class ForTest04 {
+	public static void main(String[] args) {
+		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
+		/*
+		for(int i=100; i<=999; i++) {
+
+		}
+		*/
+		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);
+			}
+		}
+	}
+}
+```
+
+## 8.6 for循环练习-统计水仙花数个数
+
+- 需求：统计“水仙花数”一共有多少个，并在控制台输出个数
+
+- 示例代码：
+
+```java
+public class ForTest05 {
+	public static void main(String[] args) {
+		//定义变量count，用于保存“水仙花数”的数量，初始值为0
+		int count = 0;
+
+		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
+		for(int i=100; i<1000; i++) {
+			//在计算之前获取三位数中每个位上的值
+			int ge = i%10;
+			int shi = i/10%10;
+			int bai = i/10/10%10;
+
+			//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
+			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
+				count++;
+			}
+		}
+
+		//打印输出最终结果
+		System.out.println("水仙花共有：" + count + "个");
+	}
+}
+```
+
+- 本题要点：
+- 今后如果需求带有统计xxx，请先想到计数器变量
+
+- 计数器变量定义的位置，必须在循环外部
+
+# 9. while循环
+
+## 9.1 while结构
+
+- while循环完整格式：
+
+```
+初始化语句;
+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++;
+		}
+
+	}
+}
+```
+
+## 9.2 while循环练习-珠穆朗玛峰
+
+- 需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
+
+- 示例代码：
+
+```java
+public class WhileTest {
+	public static void main(String[] args) {
+		//定义一个计数器，初始值为0
+		int count = 0;
+
+		//定义纸张厚度
+		double paper = 0.1;
+
+		//定义珠穆朗玛峰的高度
+		int zf = 8844430;
+
+		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
+		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
+		while(paper <= zf) {
+			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
+			paper *= 2;
+
+			//在循环中执行累加，对应折叠了多少次
+			count++;
+		}
+
+		//打印计数器的值
+		System.out.println("需要折叠：" + count + "次");
+	}
+}
+```
+
+# 10. 循环细节
+
+## 10.1 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);
+
+	}
+}
+```
+
+## 10.2 三种循环的区别
+
+- 三种循环的区别
+
+1. for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
+
+2. do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
+
+- for循环和while的区别
+
+1. 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
+
+2. 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
+
+- 死循环（无限循环）的三种格式
+
+1. for(;; ){}
+
+2. while(true){}
+
+3. do {} while(true);
+
+## 10.3 跳转控制语句
+
+- 跳转控制语句（break）
+  - 跳出循环，结束循环
+
+- 跳转控制语句（continue）
+  - 跳过本次循环，继续下次循环
+
+- 注意： continue只能在循环中进行使用！
+
+## 10.4 循环嵌套
+
+- 循环嵌套概述：在循环中，继续定义循环
+
+- 示例代码：
+
+```java
+public class ForForDemo {
+	public static void main(String[] args) {
+		for(int hour=0; hour<24; hour++) {
+			for(int minute=0; minute<60; minute++) {
+				System.out.println(hour + "时" + minute + "分");
+			}
+			System.out.println("--------");
+		}
+	}
+}
+```
+
+- 理解：
+- 请反复理解这句话（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）
+- 结论：
+- 外循环执行一次，内循环执行一圈。
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221209 Java\347\232\204Random\351\232\217\346\234\272\346\225\260\344\270\216IDEA\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\346\225\260\347\273\204.md" "b/07 \345\206\257\345\273\272\347\250\213/20221209 Java\347\232\204Random\351\232\217\346\234\272\346\225\260\344\270\216IDEA\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3d25362d6688f6e0623ce7d30365f1ff005cbeeb
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221209 Java\347\232\204Random\351\232\217\346\234\272\346\225\260\344\270\216IDEA\345\274\200\345\217\221\345\267\245\345\205\267\345\217\212\346\225\260\347\273\204.md"	
@@ -0,0 +1,499 @@
+# 11. Random
+
+## 11.1 Random产生随机数
+
+- 概述：
+  - Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
+    - API后续课程详细讲解，现在可以简单理解为Java已经写好的代码
+
+使用步骤：
+
+1. 导入包
+
+   import java.util.Random;
+
+2. 创建对象
+
+   Random r = new Random();
+
+3. 产生随机数
+
+   int num = r.nextInt(10);
+
+   解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
+
+- 示例代码：
+
+```java
+import java.util.Random;
+
+public class RandomDemo {
+	public static void main(String[] args) {
+		//创建对象
+		Random r = new Random();
+
+		//用循环获取10个随机数
+		for(int i=0; i<10; i++) {
+			//获取随机数
+			int number = r.nextInt(10);
+			System.out.println("number:" + number);
+		}
+
+		//需求：获取一个1-100之间的随机数
+		int x = r.nextInt(100) + 1;
+		System.out.println(x);
+	}
+}
+```
+
+## 11.2 Random练习-猜数字
+
+- 需求：
+
+程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+
+当猜错的时候根据不同情况给出相应的提示
+
+A. 如果猜的数字比真实数字大，提示你猜的数据大了
+
+B. 如果猜的数字比真实数字小，提示你猜的数据小了
+
+C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
+
+- 示例代码：
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class RandomTest {
+	public static void main(String[] args) {
+		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
+		Random r = new Random();
+		int number = r.nextInt(100) + 1;
+
+		while(true) {
+			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
+			Scanner sc = new Scanner(System.in);
+
+			System.out.println("请输入你要猜的数字：");
+			int guessNumber = sc.nextInt();
+
+			//比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
+			if(guessNumber > number) {
+				System.out.println("你猜的数字" + guessNumber + "大了");
+			} else if(guessNumber < number) {
+				System.out.println("你猜的数字" + guessNumber + "小了");
+			} else {
+				System.out.println("恭喜你猜中了");
+				break;
+			}
+		}
+	}
+}
+```
+
+# 12. IDEA开发工具
+
+参见：IDEA工具安装详解.pdf
+[IDEA工具安装详解.pdf](
+
+# 13. 数组
+
+### 13.2.1 第一种
+
+ 数据类型[] 数组名
+
+ 示例：
+
+```
+int[] arr;        
+double[] arr;      
+char[] arr;
+```
+
+定义了一个int类型的数组,数组名是arr
+
+### 13.2.2 第二种(不推荐)
+
+ 数据类型 数组名[]
+
+ 示例：
+
+```
+int arr[];
+double arr[];
+char arr[];
+```
+
+定义了一个int类型的变量,变量名是arr数组
+
+## 13.3 数组动态初始化
+
+数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+### 13.3.2 动态初始化格式
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度];
+```
+
+```java
+int[] arr = new int[3];
+```
+
+### 13.3.3动态初始化格式详解
+
+- 等号左边：
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - arr:代表数组的名称
+
+- 等号右边：
+  - new:为数组开辟内存空间
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - 3:代表数组的长度
+
+## 13.4 数组元素访问
+
+### 13.4.1 什么是索引
+
+ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
+
+### 13.4.2 访问数组元素格式
+
+```
+数组名[索引];
+```
+
+### 13.4.3 示例代码
+
+```java
+public class ArrayDemo {
+    public static void main(String[] args) {
+        int[] arr = new int[3];
+
+        //输出数组名
+        System.out.println(arr); //[I@880ec60
+
+        //输出数组中的元素
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+    }
+}
+```
+
+## 13.5 内存分配
+
+### 13.5.1 内存概述
+
+内存是计算机中的重要原件，临时存储区域，作用是运行程序。
+
+ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
+
+ 必须放进内存中才能运行，运行完毕后会清空内存。
+
+ Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
+
+### 13.5.2 java中的内存分配
+
+- 目前我们只需要记住两个内存，分别是：栈内存和堆内存
+
+|  区域名称  |                            作用                            |
+| :--------: | :--------------------------------------------------------: |
+|   寄存器   |                给CPU使用，和我们开发无关。                 |
+| 本地方法栈 |     JVM在使用操作系统功能的时候使用，和我们开发无关。      |
+|   方法区   |                 存储可以运行的class文件。                  |
+|   堆内存   |      存储对象或者数组，new来创建的，都存储在堆内存。       |
+|   方法栈   | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
+
+## 13.6 单个数组的内存图
+
+![](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/13.6.png)
+
+## 13.7 多个数组的内存图
+
+![](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/13.7.png)
+
+## 13.8 多个数组指向相同内存图
+
+![](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/13.8.png)
+
+## 13.9 数组静态初始化
+
+### 13.9.1 什么是静态初始化
+
+ 在创建数组时，直接将元素确定
+
+### 13.9.2 静态初始化格式
+
+- 完整版格式
+
+```
+数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+```
+
+- 简化版格式
+
+```
+数据类型[] 数组名 = {元素1,元素2,...};
+```
+
+### 13.9.3 示例代码
+
+```Java
+public class ArrayDemo {
+    public static void main(String[] args) {
+        //定义数组
+        int[] arr = {1, 2, 3};
+
+        //输出数组名
+        System.out.println(arr);
+
+        //输出数组中的元素
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+    }
+}
+```
+
+## 13.10 数组操作的两个常见小问题
+
+### 13.10.1 索引越界异常
+
+- 出现原因
+
+```java
+public class ArrayDemo {
+    public static void main(String[] args) {
+        int[] arr = new int[3];
+		System.out.println(arr[3]);
+    }
+}
+```
+
+数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+
+程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+- 解决方案
+
+
+将错误的索引修改为正确的索引范围即可！
+
+### 13.10.2 空指针异常
+
+- 出现原因
+
+```java
+public class ArrayDemo {
+    public static void main(String[] args) {
+        int[] arr = new int[3];
+		//把null赋值给数组
+        arr = null;
+        System.out.println(arr[0]);
+    }
+}
+```
+
+arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+- 解决方案
+
+
+给数组一个真正的堆内存空间引用即可！
+
+## 13.11 数组遍历
+
+- 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+
+```java
+public class ArrayTest01 {
+	public static void main(String[] args) {
+		int[] arr = { 1, 2, 3, 4, 5 };
+		System.out.println(arr[0]);
+		System.out.println(arr[1]);
+		System.out.println(arr[2]);
+		System.out.println(arr[3]);
+		System.out.println(arr[4]);
+	}
+}
+```
+
+以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。
+
+```java
+public class ArrayTest01 {
+    public static void main(String[] args) {
+        //定义数组
+        int[] arr = {11, 22, 33, 44, 55};
+
+        //使用通用的遍历格式
+        for(int x=0; x<arr.length; x++) {
+            System.out.println(arr[x]);
+        }
+    }
+}
+```
+
+## 13.12 数组最值
+
+- 最大值获取：从数组的所有元素中找出最大值。
+
+- 实现思路：
+  - 定义变量，保存数组0索引上的元素
+  - 遍历数组，获取出数组中的每个元素
+  - 将遍历到的元素和保存数组0索引上值的变量进行比较
+  - 如果数组元素的值大于了变量的值，变量记录住新的值
+  - 数组循环遍历结束，变量保存的就是数组中的最大值
+
+- 代码实现：
+
+```java
+public class ArrayTest02 {
+    public static void main(String[] args) {
+        //定义数组
+        int[] arr = {12, 45, 98, 73, 60};
+
+        //定义一个变量，用于保存最大值
+        //取数组中第一个数据作为变量的初始值
+        int max = arr[0];
+
+        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
+        for(int x=1; x<arr.length; x++) {
+            if(arr[x] > max) {
+                max = arr[x];
+            }
+        }
+
+        //循环结束后打印变量的值
+        System.out.println("max:" + max);
+
+    }
+}
+```
+
+## 13.13 作业：评委打分
+
+### 13.13.1 案例需求
+
+闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】。
+
+### 13.13.2 代码实现
+
+```java
+/*
+    思路：
+        1:定义一个数组，用动态初始化完成数组元素的初始化，长度为10
+        2:键盘录入评委分数
+        3:由于是10个评委打分，所以，接收评委分数的操作，用循环改进
+        4:定义方法实现获取数组中的最高分(数组最大值)，调用方法
+        5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法
+        6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
+        7:按照计算规则进行计算得到平均分
+        8:输出平均分
+ */
+public class Test10 {
+    public static void main(String[] args) {
+        //定义一个数组，用动态初始化完成数组元素的初始化，长度为10
+        int[] arr = new int[10];
+
+        //键盘录入评委分数
+        Scanner sc = new Scanner(System.in);
+
+        //由于是10个评委打分，所以，接收评委分数的操作，用循环改进
+        for(int x=0; x<arr.length; x++) {
+            System.out.println("请输入第" + (x + 1) + "个评委的打分：");
+            arr[x] = sc.nextInt();
+        }
+
+        //printArray(arr);
+
+        //定义方法实现获取数组中的最高分(数组最大值)，调用方法
+        int max = getMax(arr);
+
+        //定义方法实现获取数组中的最低分(数组最小值) ，调用方法
+        int min = getMin(arr);
+
+        //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
+        int sum = getSum(arr);
+
+        //按照计算规则进行计算得到平均分
+        int avg = (sum - max - min) / (arr.length - 2);
+
+        //输出平均分
+        System.out.println("选手的最终得分是：" + avg);
+
+    }
+
+    /*
+        两个明确：
+            返回值类型：int
+            参数：int[] arr
+     */
+    public static int getSum(int[] arr) {
+        int sum = 0;
+
+        for(int x=0; x<arr.length; x++) {
+            sum += arr[x];
+        }
+
+        return sum;
+    }
+
+    /*
+        两个明确：
+            返回值类型：int
+            参数：int[] arr
+     */
+    public static int getMin(int[] arr) {
+        int min = arr[0];
+
+        for(int x=1; x<arr.length; x++) {
+            if(arr[x] < min) {
+                min = arr[x];
+            }
+        }
+
+        return min;
+    }
+
+    /*
+        两个明确：
+            返回值类型：int
+            参数：int[] arr
+     */
+    public static int getMax(int[] arr) {
+        int max = arr[0];
+
+        for(int x=1; x<arr.length; x++) {
+            if(arr[x] > max) {
+                max = arr[x];
+            }
+        }
+
+        return max;
+    }
+
+    //遍历数组
+    public static void printArray(int[] arr) {
+        System.out.print("[");
+
+        for (int x = 0; x < arr.length; x++) {
+            if (x == arr.length - 1) {
+                System.out.print(arr[x]);
+            } else {
+                System.out.print(arr[x] + ", ");
+            }
+        }
+
+        System.out.println("]");
+    }
+}
+```
+
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221215 Java\347\232\204\346\226\271\346\263\225\345\217\212\344\275\234\344\270\232.md" "b/07 \345\206\257\345\273\272\347\250\213/20221215 Java\347\232\204\346\226\271\346\263\225\345\217\212\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..84135d147c8c9883584de9fb2c534d4dfb70ad17
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221215 Java\347\232\204\346\226\271\346\263\225\345\217\212\344\275\234\344\270\232.md"	
@@ -0,0 +1,398 @@
+---
+typora-root-url: D:\java仓库\java-base\07 冯建程\Java笔记图片补充
+---
+
+# 14. 方法概述
+
+## 14.1 方法的概念
+
+方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
+
+![](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/14.1.png)
+
+![](D:/java仓库/java-base/07 冯建程/Java笔记图片补充/14.1.1.png)
+
+- 注意：
+  - 方法必须先创建才可以使用，该过程成为方法定义
+  - 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
+
+## 14.2. 方法的定义和调用
+
+### 14.2.1 无参数方法定义和调用
+
+- 定义格式：
+
+```
+public static void 方法名 (   ) {
+	// 方法体;
+}
+```
+
+- 范例：
+
+```
+public static void method (    ) {
+	// 方法体;
+}
+```
+
+- 调用格式：
+
+```Java
+方法名();
+```
+
+- 范例：
+
+```java
+method();
+```
+
+- 注意：
+
+  方法必须先定义，后调用，否则程序将报错
+
+### 14.2.2 方法调用过程图解
+
+![](/../../../../java仓库/java-base/07 冯建程/Java笔记图片补充/14.2.2.png)
+
+- 总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。
+
+### 14.2.3 无参数方法的练习
+
+- 需求：设计一个方法用于打印两个数中的较大数
+- 思路：
+  - ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
+  - ②方法中定义两个变量，用于保存两个数字
+  - ③使用分支语句分两种情况对两个数字的大小关系进行处理
+  - ④在main()方法中调用定义好的方法
+
+- 代码：
+
+```java
+public class MethodTest {
+    public static void main(String[] args) {
+        //在main()方法中调用定义好的方法
+        getMax();
+    }
+
+    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
+    public static void getMax() {
+        //方法中定义两个变量，用于保存两个数字
+        int a = 10;
+        int b = 20;
+
+        //使用分支语句分两种情况对两个数字的大小关系进行处理
+        if(a > b) {
+            System.out.println(a);
+        } else {
+            System.out.println(b);
+        }
+    }
+}
+```
+
+## 14.3 带参数方法定义和调用
+
+### 14.3.1 带参数方法定义和调用
+
+- 定义格式：
+
+  参数：由数据类型和变量名组成 - 数据类型 变量名
+
+  参数范例：int a
+
+```java
+public static void 方法名 (参数1) {
+	方法体;
+}
+
+public static void 方法名 (参数1, 参数2, 参数3...) {
+	方法体;
+}
+```
+
+- 范例：
+
+```java
+public static void isEvenNumber(int number){
+    ...
+}
+public static void getMax(int num1, int num2){
+    ...
+}
+```
+
+- 注意：
+
+```java
+方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
+
+方法定义时，多个参数之间使用逗号( ，)分隔
+```
+
+- 调用格式：
+
+```java
+方法名(参数)；
+
+方法名(参数1,参数2);
+```
+
+- 范例：
+
+```java
+isEvenNumber(10);
+
+getMax(10,20);
+```
+
+- 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
+
+### 14.3.2 形参和实参
+
+1. 形参：方法定义中的参数
+
+ 等同于变量定义格式，例如：int number
+
+1. 实参：方法调用中的参数
+
+ 等同于使用变量或常量，例如： 10 number
+
+### 14.3.3 带参数方法练习
+
+- 需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }
+- 思路：
+  - ①定义一个方法用于打印两个数字中的较大数，例如getMax()
+  - ②为方法定义两个参数，用于接收两个数字
+  - ③使用分支语句分两种情况对两个数字的大小关系进行处理
+  - ④在main()方法中调用定义好的方法（使用常量）
+  - ⑤在main()方法中调用定义好的方法（使用变量）
+
+- 代码：
+
+```java
+public class MethodTest {
+    public static void main(String[] args) {
+        //在main()方法中调用定义好的方法（使用常量）
+        getMax(10,20);
+        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
+        //getMax(30);
+        //getMax(10.0,20.0);
+
+        //在main()方法中调用定义好的方法（使用变量）
+        int a = 10;
+        int b = 20;
+        getMax(a, b);
+    }
+
+    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
+    //为方法定义两个参数，用于接收两个数字
+    public static void getMax(int a, int b) {
+        //使用分支语句分两种情况对两个数字的大小关系进行处理
+        if(a > b) {
+            System.out.println(a);
+        } else {
+            System.out.println(b);
+        }
+    }
+}
+```
+
+## 14.4 带返回值方法的定义和调用
+
+### 14.4.1 带返回值方法定义和调用
+
+- 定义格式
+
+```java
+public static 数据类型 方法名 ( 参数 ) { 
+	return 数据 ;
+}
+```
+
+- 范例
+
+```java
+public static boolean isEvenNumber( int number ) {           
+	return true ;
+}
+public static int getMax( int a, int b ) {
+	return  100 ;
+}
+```
+
+- 注意：
+  - 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
+
+- 调用格式
+
+```java
+方法名 ( 参数 ) ;
+数据类型 变量名 = 方法名 ( 参数 ) ;
+```
+
+- 范例
+
+```java
+isEvenNumber ( 5 ) ;
+boolean  flag =  isEvenNumber ( 5 ); 
+```
+
+- 注意：
+  - 方法的返回值通常会使用变量接收，否则该返回值将无意义
+
+### 14.4.2 带返回值方法练习
+
+- 需求：设计一个方法可以获取两个数的较大值，数据来自于参数
+- 思路：
+  - ①定义一个方法，用于获取两个数字中的较大数
+  - ②使用分支语句分两种情况对两个数字的大小关系进行处理
+  - ③根据题设分别设置两种情况下对应的返回结果
+  - ④在main()方法中调用定义好的方法并使用变量保存
+  - ⑤在main()方法中调用定义好的方法并直接打印结果
+
+- 代码：
+
+```java
+public class MethodTest {
+    public static void main(String[] args) {
+        //在main()方法中调用定义好的方法并使用变量保存
+        int result = getMax(10,20);
+        System.out.println(result);
+
+        //在main()方法中调用定义好的方法并直接打印结果
+        System.out.println(getMax(10,20));
+    }
+
+    //定义一个方法，用于获取两个数字中的较大数
+    public static int getMax(int a, int b) {
+        //使用分支语句分两种情况对两个数字的大小关系进行处理
+        //根据题设分别设置两种情况下对应的返回结果
+        if(a > b) {
+            return a;
+        } else {
+            return b;
+        }
+    }
+}
+```
+
+## 14.5 方法的注意事项
+
+### 14.5.1 方法的注意事项
+
+- 方法不能嵌套定义
+  - 示例代码：
+
+```java
+public class MethodDemo {
+    public static void main(String[] args) {
+
+    }
+
+    public static void methodOne() {
+		public static void methodTwo() {
+       		// 这里会引发编译错误!!!
+    	}
+    }
+}
+```
+
+- void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
+- 示例代码：
+
+```java
+public class MethodDemo {
+    public static void main(String[] args) {
+
+    }
+    public static void methodTwo() {
+        //return 100; 编译错误，因为没有具体返回值类型
+        return;	
+        //System.out.println(100); return语句后面不能跟数据或代码
+    }
+}
+```
+
+### 14.5.2 方法的通用格式
+
+- 格式：
+
+```
+public static 返回值类型 方法名(参数) {
+   方法体; 
+   return 数据 ;
+}
+```
+
+- 解释：
+
+  - public static 修饰符，目前先记住这个格式
+
+    返回值类型 方法操作完毕之后返回的数据的数据类型
+
+     如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
+
+    方法名 调用方法时候使用的标识
+
+    参数 由数据类型和变量名组成，多个参数之间用逗号隔开
+
+    方法体 完成功能的代码块
+
+    return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
+
+- 定义方法时，要做到两个明确
+
+  - 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
+  - 明确参数：主要是明确参数的类型和数量
+
+- 调用方法时的注意：
+
+  - void类型的方法，直接调用即可
+  - 非void类型的方法，推荐用变量接收调用
+
+## 14.6 作业
+
+### 14.6.1 案例需求
+
+定义一函数，用于求2个数中的较大数，并将其返回，这2个数字在主函数中由用户输入
+
+### 12.6.2 代码实现
+
+```java
+package com;
+public class Test {
+    public static void main(String[] args) {
+        System.out.println("max = " + max(5, 8));
+    }
+    public static int max(int num1, int num2) {
+        return num1 > num2 ? num1 : num2;
+    }
+}
+```
+
+### 14.6.3 案例需求
+
+在主函数中从键盘接收X, Y , Z3个数，编写函数计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3
+
+### 14.6.4 代码实现
+
+```java
+import java.util.Scanner;
+public class Main{
+	public static void main(String args[]){
+		Scanner in = new Scanner(System.in);
+		int a = in.nextInt();
+		int b = in.nextInt();
+		int c = in.nextInt();
+		float sum;
+		double aver;
+		sum=a+b+c;
+		aver=sum/3.0;
+		System.out.printf("sum=%.1f\n",sum);
+		System.out.print("average="+aver);
+	}
+}
+```
+
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221216 Java\347\232\204\346\226\271\346\263\225\351\207\215\350\275\275\345\217\212\345\217\202\346\225\260\344\274\240\351\200\222.md" "b/07 \345\206\257\345\273\272\347\250\213/20221216 Java\347\232\204\346\226\271\346\263\225\351\207\215\350\275\275\345\217\212\345\217\202\346\225\260\344\274\240\351\200\222.md"
new file mode 100644
index 0000000000000000000000000000000000000000..333011d28e91af05c5582390e6c9942ca38b7189
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221216 Java\347\232\204\346\226\271\346\263\225\351\207\215\350\275\275\345\217\212\345\217\202\346\225\260\344\274\240\351\200\222.md"	
@@ -0,0 +1,268 @@
+---
+typora-root-url: D:\java仓库\java-base\07 冯建程\Java笔记图片补充
+---
+
+## 14.6 方法重载
+
+### 14.6.1 方法重载
+
+- 方法重载概念
+
+  方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
+
+  - 多个方法在同一个类中
+  - 多个方法具有相同的方法名
+  - 多个方法的参数不相同，类型不同或者数量不同
+
+- 注意：
+
+  - 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
+  - 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
+
+- 正确范例：
+
+```java
+public class MethodDemo {
+	public static void fn(int a) {
+    	//方法体
+    }
+    public static int fn(double a) {
+    	//方法体
+    }
+}
+
+public class MethodDemo {
+	public static float fn(int a) {
+    	//方法体
+    }
+    public static int fn(int a , int b) {
+    	//方法体
+    }
+}
+```
+
+- 错误范例：
+
+```Java
+public class MethodDemo {
+	public static void fn(int a) {
+    	//方法体
+    }
+    public static int fn(int a) { 	/*错误原因：重载与返回值无关*/
+    	//方法体
+    }
+}
+
+public class MethodDemo01 {
+    public static void fn(int a) {
+        //方法体
+    }
+} 
+public class MethodDemo02 {
+    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
+        //方法体
+    }
+}
+```
+
+### 14.6.2 方法重载练习
+
+- 需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
+- 思路：
+- - ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
+  - ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
+  - ③定义所有的重载方法，两个byte类型与两个short类型参数
+  - ④完成方法的调用，测试运行结果
+- 代码：
+
+```java
+public class MethodTest {
+    public static void main(String[] args) {
+        //调用方法
+        System.out.println(compare(10, 20));
+        System.out.println(compare((byte) 10, (byte) 20));
+        System.out.println(compare((short) 10, (short) 20));
+        System.out.println(compare(10L, 20L));
+    }
+
+    //int
+    public static boolean compare(int a, int b) {
+        System.out.println("int");
+        return a == b;
+    }
+
+    //byte
+    public static boolean compare(byte a, byte b) {
+        System.out.println("byte");
+        return a == b;
+    }
+
+    //short
+    public static boolean compare(short a, short b) {
+        System.out.println("short");
+        return a == b;
+    }
+
+    //long
+    public static boolean compare(long a, long b) {
+        System.out.println("long");
+        return a == b;
+    }
+
+}
+```
+
+## 14.7 方法的参数传递
+
+### 14.7.1 方法参数传递基本类型
+
+- 测试代码：
+
+```java
+public class ArgsDemo01 {
+    public static void main(String[] args) {
+        int number = 100;
+        System.out.println("调用change方法前：" + number);
+        change(number);
+        System.out.println("调用change方法后：" + number);
+    }
+
+    public static void change(int number) {
+        number = 200;
+    }
+}
+```
+
+- 结论：
+  - 基本数据类型的参数，形式参数的改变，不影响实际参数
+- 结论依据：
+  - 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
+
+![](/14.7.1.png)
+
+### 14.7.2 方法参数传递引用类型
+
+- 测试代码：
+
+```java
+public class ArgsDemo02 {
+    public static void main(String[] args) {
+        int[] arr = {10, 20, 30};
+        System.out.println("调用change方法前：" + arr[1]);
+        change(arr);
+        System.out.println("调用change方法后：" + arr[1]);
+    }
+
+    public static void change(int[] arr) {
+        arr[1] = 200;
+    }
+}
+```
+
+- 结论：
+  - 对于引用类型的参数，形式参数的改变，影响实际参数的值
+- 结论依据：
+  - 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果
+
+![](/14.7.2.png)
+
+### 14.7.3 数组遍历
+
+- 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
+- 思路：
+
+①因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
+
+System.out.println(“内容”); 输出内容并换行
+
+System.out.print(“内容”); 输出内容不换行
+
+System.out.println(); 起到换行的作用
+
+②定义一个数组，用静态初始化完成数组元素初始化
+
+③定义一个方法，用数组遍历通用格式对数组进行遍历
+
+④用新的输出语句修改遍历操作
+
+⑤调用遍历方法
+
+- 代码：
+
+```java
+public class MethodTest01 {
+    public static void main(String[] args) {
+        //定义一个数组，用静态初始化完成数组元素初始化
+        int[] arr = {11, 22, 33, 44, 55};
+
+        //调用方法
+        printArray(arr);
+    }
+
+    //定义一个方法，用数组遍历通用格式对数组进行遍历
+    /*
+        两个明确：
+            返回值类型：void
+            参数：int[] arr
+     */
+    public static void printArray(int[] arr) {
+        System.out.print("[");
+        for(int x=0; x<arr.length; x++) {
+            if(x == arr.length-1) {
+                System.out.print(arr[x]);
+            } else {
+                System.out.print(arr[x]+", ");
+            }
+        }
+        System.out.println("]");
+    }
+}
+```
+
+### 14.7.4 数组最大值
+
+- 需求：设计一个方法用于获取数组中元素的最大值
+- 思路：
+
+①定义一个数组，用静态初始化完成数组元素初始化
+
+②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
+
+③调用获取最大值方法，用变量接收返回结果
+
+④把结果输出在控制台
+
+- 代码：
+
+```java
+public class MethodTest02 {
+    public static void main(String[] args) {
+        //定义一个数组，用静态初始化完成数组元素初始化
+        int[] arr = {12, 45, 98, 73, 60};
+
+        //调用获取最大值方法，用变量接收返回结果
+        int number = getMax(arr);
+
+        //把结果输出在控制台
+        System.out.println("number:" + number);
+    }
+
+    //定义一个方法，用来获取数组中的最大值
+    /*
+        两个明确：
+            返回值类型：int
+            参数：int[] arr
+     */
+    public static int getMax(int[] arr) {
+        int max = arr[0];
+
+        for(int x=1; x<arr.length; x++) {
+            if(arr[x] > max) {
+                max = arr[x];
+            }
+        }
+        return max;
+    }
+}
+```
+
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221220 Java\347\232\204\350\267\263\350\277\207\345\276\252\347\216\257.md" "b/07 \345\206\257\345\273\272\347\250\213/20221220 Java\347\232\204\350\267\263\350\277\207\345\276\252\347\216\257.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cc53d531a214fc427100572294208e3779305b07
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221220 Java\347\232\204\350\267\263\350\277\207\345\276\252\347\216\257.md"	
@@ -0,0 +1,40 @@
+# 笔记
+
+```java
+public class test7 {
+    public static void main(String[] args) {
+        int[] [] arr={
+                {1,32,6},
+                {34,2,12},
+                {18,34,64},
+                {45,22,62}
+        };
+        System.out.println(arr[1][0]);//输处第二个数组里的第一个值34
+        for (int i=0; i<arr.length;i++){
+            for (int j=0; j<arr[i].length;j++){
+                System.out.print(arr[i][j]+"\t");//不换行 "\t"加空格
+            }
+            System.out.println(); //在内循环的输出结束后换行
+        }
+    }
+}
+```
+
+# 作业
+
+```java
+public static void welCome(){
+        //       先列出系统的功能
+        System.out.println("=================================");
+        System.out.println("-     欢迎使用大学牲管理系统\t-");
+        System.out.println("-   \t1.浏览所有学生信息\t\t-");
+        System.out.println("-   \t2.添加学生信息\t\t-");
+        System.out.println("-   \t3.修改学生信息\t\t-");
+        System.out.println("-   \t4.删除学生信息\t\t-");
+        System.out.println("-   \t5.查询学生信息\t\t-");
+        System.out.println("-   \t6.退出管理系统\t\t-");
+        System.out.println("=================================");
+        System.out.println("请输入对应数字选择你需要的功能:");
+
+    }
+```
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221222 \345\255\246\347\224\237\347\256\241\347\220\206\347\263\273\347\273\237\344\275\234\344\270\232\345\256\214\346\225\264\344\273\243\347\240\201\345\217\212\346\200\235\350\267\257\350\277\207\347\250\213.md" "b/07 \345\206\257\345\273\272\347\250\213/20221222 \345\255\246\347\224\237\347\256\241\347\220\206\347\263\273\347\273\237\344\275\234\344\270\232\345\256\214\346\225\264\344\273\243\347\240\201\345\217\212\346\200\235\350\267\257\350\277\207\347\250\213.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5db2fd4ae04a08f0b88a1ec920ba0decbd5accf1
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221222 \345\255\246\347\224\237\347\256\241\347\220\206\347\263\273\347\273\237\344\275\234\344\270\232\345\256\214\346\225\264\344\273\243\347\240\201\345\217\212\346\200\235\350\267\257\350\277\207\347\250\213.md"	
@@ -0,0 +1,660 @@
+# 学生管理系统作业完整代码及思路过程
+
+### 完整代码：
+
+```java
+public class Hw {
+    public static void main(String[] args) {
+        int count = 1;
+        int redFlag = 1;
+        Stu a[] = new Stu[1];
+        a[0] = new Stu("84G0235", "小雅", "女", 18, 89);
+ 
+        Scanner scan = new Scanner(System.in);
+        Hw test = new Hw();
+        System.out.println("欢迎来到学生信息管理系统");
+        while (redFlag == 1) {
+            test.putMenu();
+            int data0 = scan.nextInt();
+            switch (data0) {
+            case 0:
+                redFlag = 0;
+                break;
+            case 1:
+                test.putAllStu(a, count);
+                break;
+            case 2:
+                a = test.inPutStu(a, count,scan);
+                count++;
+ 
+                // 如果数组中已实例化元素个数等于a的长度，扩容
+                break;
+            case 3:
+                test.selectStu(a, count, scan);
+                break;
+            case 4:
+                a = test.reSetStu(a, count , scan);
+                break;
+            case 5:
+                a = test.delete(a, count, scan);
+                count--;
+                break;
+            }
+ 
+        }
+ 
+    }
+ 
+    void putMenu() {
+        System.out.println("<————————————————————>");
+        System.out.println("请输入你所要操作的项目标号");
+        System.out.println("1.显示所有学生信息");
+        System.out.println("2.录入学生信息");
+        System.out.println("3.查询学生信息");
+        System.out.println("4.修改学生信息");
+        System.out.println("5.删除学生信息");
+        System.out.println("0.退出系统");
+    }// 显示所有学生信息。
+ 
+    Stu[] putAllStu(Stu a[], int count) {
+        for (int i = 0; i < count; i++) {
+            System.out.print(i + 1 + ":");
+            System.out.print("学号：" + a[i].getStuNum());
+            System.out.print(" 姓名：" + a[i].getName());
+            System.out.print(" 性别：" + a[i].getGender());
+            System.out.print(" 年龄：" + a[i].getAge());
+            System.out.println(" 成绩：" + a[i].getMark());
+ 
+        }
+        return a;
+ 
+    }// 显示所有学生信息。
+ 
+    Stu[] inPutStu(Stu a[], int count,Scanner scan) {
+        if (count == a.length) {
+            a = Hw.newArray(a);
+        }
+       
+        System.out.println("请输入录入学生学号：");
+        String newStuNum = scan.next().trim();
+ 
+        System.out.println("请输入录入学生姓名：");
+        String newName = scan.next().trim();
+ 
+        System.out.println("请输入录入学生性别：");
+        String newGender = scan.next().trim();
+        while (true) {
+            if (newGender.equals("男") || newGender.equals("女")) {
+                break;
+            } else {
+                System.out.println("输入有误，重新输入");
+                newGender = scan.next();
+            }
+ 
+        }
+ 
+        System.out.println("请输入录入学生年龄：");
+        int newAge = scan.nextInt();
+ 
+        System.out.println("请输入录入学生成绩：");
+        int newMake = scan.nextInt();
+ 
+        a[count] = new Stu(newStuNum, newName, newGender, newAge, newMake);
+ 
+        return a;
+    }// 录入学生信息。
+ 
+    void selectStu(Stu a[], int count ,Scanner scan) {        
+        System.out.println("请输入要查找的学生姓名：");
+        String name = scan.next().trim();
+        for (int i = 0; i < count; i++) {
+            if (a[i].getName().equals(name)) {
+                System.out.print("学号：" + a[i].getStuNum());
+                System.out.print(" 姓名：" + a[i].getName());
+                System.out.print(" 性别：" + a[i].getGender());
+                System.out.print(" 年龄：" + a[i].getAge());
+                System.out.print(" 成绩：" + a[i].getMark());
+                System.out.println(" 在系统中的位置为：" + i);
+                
+                return ;    
+            }
+        }
+        System.out.println("查无此人");
+        return ;
+    }// 查找学生信息。
+ 
+    Stu[] reSetStu(Stu a[], int count,Scanner scan) {
+        System.out.println("请输入要修改的学生学号：");
+        String stuNum = scan.next().trim();
+        for (int i = 0; i < count; i++) {
+            if (a[i].getStuNum().equals(stuNum)) {
+                System.out.println("您将要修改的学生信息如下：");
+                System.out.print("学号：" + a[i].getStuNum());
+                System.out.print(" 姓名：" + a[i].getName());
+                System.out.print(" 性别：" + a[i].getGender());
+                System.out.print(" 年龄：" + a[i].getAge());
+                System.out.println(" 成绩：" + a[i].getMark());
+                System.out.println("请选择您要修改的项目，输入0退出");
+                System.out.println("1.学号：");
+                System.out.println("2.姓名：");
+                System.out.println("3.性别：");
+                System.out.println("4.年龄：");
+                System.out.println("5.成绩：");
+                int flag = 1;
+                while (flag != 0) {
+                    flag = scan.nextInt();
+                    switch (flag) {
+                    case 1:
+                        System.out.println("请输入新的信息");
+                        String newStuNum = scan.next();
+                        a[i].setStuNum(newStuNum);
+                        break;
+                    case 2:
+                        System.out.println("请输入新的信息");
+                        String newName = scan.next();
+                        a[i].setStuNum(newName);
+                        break;
+                    case 3:
+                        System.out.println("请输入新的信息");
+                        String newGender = scan.next();
+                        while (true) {
+                            if (newGender.equals("男") || newGender.equals("女")) {
+                                break;
+                            } else {
+                                System.out.println("输入有误，重新输入");
+                                newGender = scan.next();
+                            }
+ 
+                        }
+                        a[i].setStuNum(newGender);
+                        break;
+                    case 4:
+                        System.out.println("请输入新的信息");
+                        int newAge = scan.nextInt();
+                        a[i].setAge(newAge);
+                        break;
+                    case 5:
+                        System.out.println("请输入新的信息");
+                        int newMark = scan.nextInt();
+                        a[i].setMark(newMark);
+                        break;
+                    default:
+                        System.out.println("请输入正确数字");
+                    }
+                    System.out.println("请继续选择您要修改的项目，输入0退出");
+                }
+                System.out.println("您修改后的学生信息如下：");
+                System.out.print("学号：" + a[i].getStuNum());
+                System.out.print(" 姓名：" + a[i].getName());
+                System.out.print(" 性别：" + a[i].getGender());
+                System.out.print(" 年龄：" + a[i].getAge());
+                System.out.println(" 成绩：" + a[i].getMark());
+                
+                return a;
+            }
+          
+        }
+         System.out.println("系统中无此学生");
+         return a;
+    }// 修改学生信息。
+ 
+    Stu[] delete(Stu a[], int count,Scanner scan) {
+        System.out.println("请输入要删除的学生学号：");
+        String stuNum = scan.nextLine();
+        for (int i = 0; i < count; i++) {
+            if (a[i].getStuNum().equals(stuNum)) {
+                for (int j = i + 1; j < count; j++) {
+                    a[j - 1] = a[j];
+                }
+            return a;
+            }
+        }
+        System.out.println("系统中无此学生");
+        return a;
+    }// 删除学生信息
+ 
+    static Stu[] newArray(Stu a[]) {
+        Stu[] newArray = new Stu[a.length + a.length];
+        for (int i = 0; i < a.length; i++)
+            newArray[i] = a[i];
+        return newArray;
+    }
+}// 数组扩容
+ 
+ 
+public class Stu {
+    private String stuNum ;//学生学号
+    private String name;//学生姓名
+    private String gender;//学生性别
+    private int age;//学生年龄
+    private int mark;//学生成绩
+    
+    public Stu(String stuNum,String name,String gender,int age,int mark) {
+        this.stuNum = stuNum;
+        this.name = name;
+        this.gender = gender;
+        this.age = age;
+        this.mark = mark;
+    }//构造方法
+    
+    public String getStuNum() {
+        return stuNum;
+    }
+    public void setStuNum(String stuNum) {
+        this.stuNum = stuNum;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public String getGender() {
+        return gender;
+    }
+    public void setGender(String gender) {
+        if(gender != "男"&&gender != "女") {
+            System.out.println("输入有误，重新操作");
+            return ;
+        }
+            
+        this.gender = gender;
+    }
+    public int getAge() {
+        return age;
+    }
+    public void setAge(int age) {
+        this.age = age;
+    }
+    public int getMark() {
+        return mark;
+    }
+    public void setMark(int mark) {
+        this.mark = mark;
+    }
+    
+}    
+```
+
+### 思路过程：
+
+简单的学生信息管理系统，通过键盘选择操作进行添加学生（学号，姓名，性别，年龄，成绩）的信息，通过数组存储，同时可以进行查询某个或全体学生信息，修改学生信息，删除学生信息的操作。
+
+到手了需求先来分析一下。要码出这样一个系统，首先我们对整个程序进行分解。
+
+在一个程序中，我们总能把一个大的程序分解成多个小程序，从而将求解整体问题分解为求解部分问题，然后在进行汇总。
+
+
+首先我们需要定义一下我们的**学生类**。如下
+
+```java
+public class Stu {
+    private String stuNum ;//学生学号
+    private String name;//学生姓名
+    private String gender;//学生性别
+    private int age;//学生年龄
+    private int mark;//学生成绩
+    
+    public Stu(String stuNum,String name,String gender,int age,int mark) {
+        this.stuNum = stuNum;
+        this.name = name;
+        this.gender = gender;
+        this.age = age;
+        this.mark = mark;
+    }//构造方法
+    
+    public String getStuNum() {
+        return stuNum;
+    }
+    public void setStuNum(String stuNum) {
+        this.stuNum = stuNum;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public String getGender() {
+        return gender;
+    }
+    public void setGender(String gender) {    
+        this.gender = gender;
+    }
+    public int getAge() {
+        return age;
+    }
+    public void setAge(int age) {
+        this.age = age;
+    }
+    public int getMark() {
+        return mark;
+    }
+    public void setMark(int mark) {
+        this.mark = mark;
+    }
+    
+}    
+```
+
+在如上的Stu类中定义了5种不同类型的私有型变量，用于记录学生的不同信息。同时定义了一个构造方法，和对私有变量的访问和修改方法。
+
+好的，对象有了，可是我们现在没有对应的方法来操作他，那我们要对象干什么呢，先把他用数组放起来吧。
+
+```java
+public class Hw {
+    public static void main(String[] args) {
+        
+        Stu a[] = new Stu[100];
+        a[0] = new Stu("84G0235","小雅","女",18,89);
+        int count = 1;
+}}
+```
+
+好的，我们定义了一个100个长度类型为Stu类的数组，并对数组的第一个元素进行实例化操作。然后定义一个count的整形变量用来记录数组中有多少个被实例化的元素。
+
+OK,安排妥当之后，我们来看看我们要对学生对象进行什么操作：
+
+显示所有学生信息，录入学生信息，查询学生信息，修改学生信息，删除学生信息。
+
+ 
+
+我们来一个一个的实现他们，首先是
+
+
+### **显示所有学生信息：**
+
+```java
+    Stu [] putAllStu(Stu a[],int count) {
+        for(int i = 0 ;i < count;i++) {
+                System.out.print(i+1 +":");
+                System.out.print("学号："+a[i].getStuNum());
+                System.out.print(" 姓名："+a[i].getName());
+                System.out.print(" 性别："+a[i].getGender());
+                System.out.print(" 年龄："+a[i].getAge());
+                System.out.println(" 成绩："+a[i].getMark());
+            
+        }
+        return a;
+            
+    }
+```
+
+OK,我们第一了一个叫putAllStu的方法，他有两个参数，一个是Stu类 类型的数组，一个是int型的变量，一个返回值，返回值的类型是一个Stu类 类型的数组。
+
+如果要调用的话实际传入的是存放学生信息的数组和被实例化的元素个数，然后随着 i 的增加，输出所有的学生信息。
+
+ 
+
+OK，我们来实现第二个功能：
+
+
+### 录入学生信息
+
+```java
+    Stu[] inPutStu(Stu a[], int count,Scanner scan) {
+        if (count == a.length) {
+            a = Hw.newArray(a);
+        }
+       
+        System.out.println("请输入录入学生学号：");
+        String newStuNum = scan.next().trim();
+ 
+        System.out.println("请输入录入学生姓名：");
+        String newName = scan.next().trim();
+ 
+        System.out.println("请输入录入学生性别：");
+        String newGender = scan.next().trim();
+        while (true) {
+            if (newGender.equals("男") || newGender.equals("女")) {
+                break;
+            } else {
+                System.out.println("输入有误，重新输入");
+                newGender = scan.next();
+            }
+ 
+        }
+ 
+        System.out.println("请输入录入学生年龄：");
+        int newAge = scan.nextInt();
+ 
+        System.out.println("请输入录入学生成绩：");
+        int newMake = scan.nextInt();
+ 
+        a[count] = new Stu(newStuNum, newName, newGender, newAge, newMake);
+ 
+        return a;
+    }// 录入学生信息。
+```
+
+ 这个方法的参数调用同上一个函数，根据提示依次输入要录入的学生信息，然后实例化数组元素，返回实例化后的数组，注意这里count（数组中被实例化的个数）的值应该加一 的，但是由于我们返回了数组，所以count+1 的步骤我们放在主函数里面进行实现。
+
+ 
+
+OK,我们来实现第三个功能。
+ 
+
+### 查询学生信息
+
+```java
+void selectStu(Stu a[],int count, Scanner scan) {
+ 
+       System.out.println("请输入要查找的学生姓名：");
+       String name = scan.next();
+       for(int i = 0 ;i < count;i++) {
+           if(a[i].getName().equals(name)) {
+ 
+               System.out.print("学号："+a[i].getStuNum());
+               System.out.print(" 姓名："+a[i].getName());
+               System.out.print(" 性别："+a[i].getGender());
+               System.out.print(" 年龄："+a[i].getAge());
+               System.out.print(" 成绩："+a[i].getMark());
+               System.out.println(" 在系统中的位置为："+i);
+               
+               return ;    
+            }
+        }
+        System.out.println("查无此人");
+        return ;
+    }// 查找学生信息。
+```
+
+这里我采用了根据学生姓名查找学生信息的方法，根据学号的方法实现类似，就不写了。这里我们让用户输入学生姓名，采用a[i].getName().equals(name)  的方法判断他们是否相等。这一部分在一开始实现的时候发现，String 类型的变量不能直接采用==和 学生类里面的元素进行比较，后百度得到 equals()  方法。
+
+这里小结一下 == 和 equals() 的区别。== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象，比较的是指针操作。equals单纯的用来比较的是两个对象的内容是否相等。
+
+ 
+
+OK，我们来实现第四个功能，
+
+
+### 修改学生信息
+
+```java
+Stu [] reSetStu(Stu a[],int count, Scanner scan) {
+ 
+       System.out.println("请输入要修改的学生学号：");
+       String stuNum = scan.next();
+       for(int i = 0 ;i < count;i++) {
+           if(a[i].getStuNum().equals(stuNum)) {
+ 
+               System.out.println("您将要修改的学生信息如下：");
+               System.out.print("学号："+a[i].getStuNum());
+               System.out.print(" 姓名："+a[i].getName());
+               System.out.print(" 性别："+a[i].getGender());
+               System.out.print(" 年龄："+a[i].getAge());
+               System.out.println(" 成绩："+a[i].getMark());
+ 
+               System.out.println("请选择您要修改的项目，输入0退出");
+               System.out.println("1.学号：");
+               System.out.println("2.姓名：");
+               System.out.println("3.性别：");
+               System.out.println("4.年龄：");
+               System.out.println("5.成绩：");
+ 
+               int flag = 1;//立旗子，如果为零退出修改
+               while (flag!=0) {
+                   flag = scan.nextInt();
+                   switch(flag) {
+                   case 1:
+                       System.out.println("请输入新的信息");
+                       String newStuNum = scan.next();
+                       a[i].setStuNum(newStuNum);
+                       break;
+                   case 2:
+                       System.out.println("请输入新的信息"); 
+                       String newName = scan.next();
+                       a[i].setStuNum(newName);
+                       break;
+                   case 3:
+                       System.out.println("请输入新的信息"); 
+                       String newGender = scan.next();
+                       while(true) {
+                           if(newGender.equals("男") || newGender.equals("女")) {
+                               break;
+                           }else {
+                               System.out.println("输入有误，重新输入");
+                               newGender = scan.next();
+                           }
+                       }
+                       a[i].setStuNum(newGender);
+                       break;
+                   case 4:
+                       System.out.println("请输入新的信息");
+                       int newAge = scan.nextInt();
+                       a[i].setAge(newAge);
+                       break;
+                   case 5:
+                       System.out.println("请输入新的信息");
+                       int newMark = scan.nextInt();
+                       a[i].setMark(newMark);
+                       break;
+                   default:
+                       System.out.println("请输入正确数字");
+                   }
+                   System.out.println("请继续选择您要修改的项目，输入0退出");
+               }
+ 
+               System.out.println("您修改后的学生信息如下：");
+               System.out.print("学号："+a[i].getStuNum());
+               System.out.print(" 姓名："+a[i].getName());
+               System.out.print(" 性别："+a[i].getGender());
+               System.out.print(" 年龄："+a[i].getAge());
+               System.out.println(" 成绩："+a[i].getMark());
+               
+                  return a;
+            }
+          
+        }
+         System.out.println("系统中无此学生");
+         return a;
+    }// 修改学生信息。
+```
+
+在这个方法中设置的是根据学号来修改学生信息，我们先让他打印了一遍原来的学生信息。然后打印了一个菜单让用户根据菜单上的数字选择要修改的信息，调用类中的set方法进行修改，可以重复进行修改，输入0退出。然后再输出修改后的信息。返回修改后的数组。
+
+OK,最后一个功能，
+
+### 删除学生信息
+
+```java
+ Stu [] delete(Stu a[],int count, Scanner scan) {
+ 
+       System.out.println("请输入要删除的学生学号：");
+       String stuNum = scan.next();
+       for(int i = 0 ;i < count;i++) {
+           if(a[i].getStuNum().equals(stuNum)) {
+               for(int j = i+1;j< count ;j++) {
+                   a[j-1]=a[j];
+ 
+               }
+           return a;
+       
+           } 
+       }
+      System.out.println("系统中无此学生");
+      return a;
+       
+   }
+```
+
+在这里我选择了使用查找学生学号的方式进行找到需要删除的学生信息位置，然后让其后面的数组元素前移。这里也应该有一个count--，在主方法里会实现。
+
+ 
+
+OK,至此我们的所有功能都实现完了。
+
+emm但还是有些问题，我在前面定义了一个100长度的数组来存放信息。但是如果我要存更多的学生信息呢？
+
+```java
+static Stu [] newArray(Stu a[]) {
+        Stu [] newArray = new Stu[a.length+a.length];
+        for(int i = 0 ;i < a.length ; i++)
+        newArray[i] = a[i] ;
+        return newArray;
+    }
+}//数组扩容
+```
+
+ OK，我们把a数组里面的信息复制到一个是a数组长度的两倍的数组里面，并返回新数组。我们把他放到 inPutStu 方法里面。在方法的开始判断数组中的被实例化的元素个数是否等于数组的长度本身如果存放学生信息 的数组满了 就调用 newArray 方法对数组扩容。
+
+我们还需要一个菜单来引导用户进行操作。
+
+```java
+void putMenu() {
+        System.out.println("<————————————————————>");
+        System.out.println("请输入你所要操作的项目标号");
+        System.out.println("1.显示所有学生信息");
+        System.out.println("2.录入学生信息");
+        System.out.println("3.查询学生信息");
+        System.out.println("4.修改学生信息");
+        System.out.println("5.删除学生信息");
+        System.out.println("0.退出系统");
+    }
+```
+
+好的，基本上该有的模块我们都有了。下面我们需要把他们糅合在一起，开始拼图。
+
+```java
+public class Hw {
+    public static void main(String[] args) {
+        int count = 1;
+        int redFlag = 1;
+        Stu a[] = new Stu[1];
+        a[0] = new Stu("84G0235","小雅","女",18,89);
+        
+        Scanner scan = new Scanner(System.in);
+        Hw test = new Hw();
+        System.out.println("欢迎来到学生信息管理系统");
+        while(redFlag==1) {
+            test.putMenu();
+            int data0 = scan.nextInt();
+            switch(data0) {
+            case 0:
+                redFlag = 0;
+                break;
+            case 1:
+                test.putAllStu(a, count); 
+                break;
+            case 2:
+                a = test.inPutStu(a, count, scan);
+                count++;
+                break;
+            case 3:
+                test.selectStu(a, count, scan);
+                break;
+            case 4:
+                a = test.reSetStu(a, count,scan);
+                break;
+            case 5:
+                a = test.delete(a, count,scan);
+                count--;
+                break;
+            }
+         
+        }
+        
+    }       
+```
+
+在完善的主方法里面，我们定义了一个颜色更加鲜艳的旗子用来实现用户的循环操作。当在菜单页面输入的数字为0时，redflag就为0，这时系统结束。在每一次的循环中都打印出菜单和等待用户输入操作对应的数字。
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/20221223 \351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260\345\217\212\344\275\234\344\270\232.md" "b/07 \345\206\257\345\273\272\347\250\213/20221223 \351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260\345\217\212\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9498929b08f25036dbc30c5b015e637e484faeae
--- /dev/null
+++ "b/07 \345\206\257\345\273\272\347\250\213/20221223 \351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260\345\217\212\344\275\234\344\270\232.md"	
@@ -0,0 +1,269 @@
+## 面向对象
+
+面向对象是一种编程思维
+
+#### 对象是什么？
+
+对象是看得到摸得着的东西，是真实存在的
+
+对象的属性和行为
+
+属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值
+
+行为：对象能够执行的操作
+
+#### 类是什么？
+
+是对现实生活中一类具有共同属性和行为的事物的抽象，确定的对象将会拥有属性和行为
+
+类的组成：属性和行为
+
+属性:在类中通过成员变量来体现（类中方法外的变量）
+
+行为：在类中通过成员方法来体现（在前面的方法相比去掉static关键字即可）
+
+二者的关系：
+
+类是对象的抽象，对象是类的实体 
+
+## 栈内存和堆内存
+
+栈内存：所有局部变量都会在栈内存中创建
+
+局部变量：定义在方法中的变量或方法声明上的变量
+
+方法执行都会加载到栈中进行
+
+局部变量的特点：随着方法的调用而存在，随着方法的调用完毕而消失
+
+例如：
+
+```java
+Student s = new Student();
+//Student s 会进入栈内存，main主方法也是在栈内存
+//而new Student会进入堆内存 
+```
+
+堆内存：所有对象及其对应的实例变量和数组都将存储在此处
+
+简单理解：每new出来的东西都会在堆内存里
+
+## 作业
+
+```java
+package 图书管理系统;
+
+import java.util.Scanner;
+
+public class BookManagerSystem {
+
+        //把扫描器放在最外层，这样里面所有的方法都能用，这个扫描器让所有公用
+//    static 改为静态的让所有公用
+        static Scanner sc = new Scanner(System.in);
+        //数组放在外面也能被所以使用，book（数组名称）相当于一个数据库
+        static String[] book = new String[5];
+        public static void main(String[] args) {
+            //定义这个数组，存放图书信息
+//        String[] book = new String[10];
+            //假设里面已经有一些图书信息
+            book[0]="精卫填海";
+            book[1]="夸父追日";
+            book[2]="女娲补天";
+            //添加从3开始，3这个索引，其实就是第一个null的位置
+            //弄一个死循环，让他一直循环start，也就是目录，还有选择菜单
+            while (true){
+                start();
+                int a = choiceMenu(sc.nextInt());
+                if (a==1){
+                    break;
+                }
+            }
+
+        }
+        //1、登入界面，\n是换行,\t空格
+        public static void start(){
+            System.out.println();
+            System.out.println("==============================" +
+                    "\n-     欢迎使用闽大图书管理系统\t- " +
+                    "\n- \t\t1.浏览所有图书信息 \t-" +
+                    "\n- \t\t2.添加图书信息 \t\t-" +
+                    "\n- \t\t3.修改图书信息 \t\t-" +
+                    "\n- \t\t4.删除图书信息 \t\t-" +
+                    "\n- \t\t5.查询图书信息 \t\t-" +
+                    "\n- \t\t6.退出管理系统 \t\t-" +
+                    "\n==============================\n" +
+                    "\n 请输入对应的数字选择你需要的功能： ");
+        }
+        //2、根据输入的数字，进入不同的分支
+        //因为是int型，所以会有返回值return
+        public static int choiceMenu(int num){
+            //定义一个变量，用于6
+            int a =0;
+            //swith会精确到某一个值，一般用于值比较少的时候
+            switch (num){
+                case 1:
+                    //1、浏览所有图书信息
+//                System.out.println("你选择了浏览所有图书");
+                    viwAllBook();
+                    break;
+                case 2:
+                    // 2.添加图书信息
+                    addBook();
+//                System.out.println("你选择了添加图书信息");
+                    break;
+                case 3:
+                    //3.修改图书信息
+                    editBook();
+                    break;
+                case 4:
+                    //4.删除图书信息
+                    deleteBook();
+                    break;
+                case 5:
+                    // 5.查询图书信息
+                    searchBook();
+                    break;
+                case 6:
+                    // 6.退出管理系统
+                    System.out.println("你选择退出系统！");
+                    a =1;
+                    break;
+                default:
+                    System.out.println("不存在！");
+            }
+            return a;
+        }
+
+
+        //   /3、浏览所有图书信息
+        public static void viwAllBook(){
+            System.out.println("闽大图书馆现有以下图书：");
+            //弄个计数器，统计null个数
+            int count = 0;
+            for (String name : book){
+//            第一种
+                if (name ==null){
+                    count++;
+                    continue;//跳过
+                }
+                System.out.print(name+"\t");
+//            第二种
+//            if (name !=null){
+//                System.out.println(name+"\t");
+//            }
+            }
+            //判断，null的个数等于数组的长度，说明整个数据库都是null，结论就是没有图书信息
+            if (count == book.length){
+                System.out.println("目前，还没有该图书信息！");
+            }
+        }
+
+        //4添加图书信息
+        public static void addBook( ) {
+//先找出没有人的位置，也就是第一个null的位置
+//然后将它成你要添加的图书
+            //提示用户输入
+            System.out.println("请输入你要添加的图书名称：");
+            //字符串的形式来接收用户所输入的文字
+            String name =sc.next();
+            //用int来接收seachIndex这个方法
+            int index = searchIndex(name);
+            //先判断是否已经有该图书
+            if (index !=-1){
+                System.out.println("该图书已经在数据库了，请不要重复添加");
+            }else {
+                //用int来接收searchIndex方法
+                int nullindex = searchIndex(null);
+//            让数据库里的null等于用户输入的新添加的图书
+                book[nullindex] =name;
+                System.out.println("添加成功！");
+                //添加到viwAllBook这个方法里，这样才算添加成功
+                viwAllBook();
+            }
+
+        }
+        //4.1把找置位的功能，独立出来，做成一个方法,返回找到的位置
+        public static int searchIndex(String str) {
+            //定义一个索引变量
+            int index = -1;//因为在数组里0表示第一个，改成-1，就表示不存在
+            //null是特殊的类型，所以要单独判断
+            if (str == null) {
+                for (int i = 0; i < book.length; i++) {
+                    if (book[i] == null) {
+                        index = i;
+                        break;
+                    }
+                }
+            }else {
+                for (int i = 0; i < book.length; i++) {
+                    if (str.equals(book[i])) {
+                        index = i;
+                        return index;
+                    }
+                }
+            }
+            return index;
+
+        }
+
+        //5.修改图书的一个方法
+        private static void editBook() {
+            //1.输入要修改的图书
+            System.out.println("请问你要修改那一本图书");
+            //字符串的形式来接收用户所输入的文字
+            String bookName = sc.next();
+            //在数组中，查找这个name所对应的索引值
+            int index = searchIndex(bookName);
+            //判断这个索引值存在不存在
+            if (index ==-1){
+                System.out.println("对不起，没有该图书，无法修改！");
+            }else {
+                //将索引值对应的元素改为用户输入的图书
+                System.out.println("请问你要把【"+bookName+"】修改为：");
+                //字符串的形式来接收用户所输入的文字
+                String newName = sc.next();
+                //把数据库里的值换为用户输入的值
+                book[index] =newName;
+                System.out.println("修改成功！");
+            }
+        }
+        //6.删除图书信息
+        public static void deleteBook(){
+            //1.输入要删除的图书
+            System.out.println("请问你要删除那一本图书");
+            //字符串的形式来接收用户所输入的文字
+            String name = sc.next();
+            //在数组中，查找这个name所对应的索引值
+            int index = searchIndex(name);
+            //判断这个索引值存在不存在
+            if (index ==-1){
+                System.out.println("对不起，没有该图书，无法删除！");
+            }else {
+                //把数据库里的数据换为null空的
+                book[index] =null;
+                System.out.println("删除成功！");
+            }
+        }
+        //    7.查询图书信息
+        private static void searchBook() {
+            System.out.println("请输入要查询图书：");
+            //字符串的形式来接收用户所输入的文字
+            String name = sc.next();
+            //引用方法，该方法用int来接收这个方法
+            //查找这个图书的索引
+            int index = searchIndex(name);
+            //判断若是该图书找不到就返回-1，找到了就返回索引+1
+            if (index == -1){
+                System.out.println("对不起，没有找到该图书！");
+            }else {
+                //index+1是因为计算机是从0开始算一位数，+上1才是我们 正常的
+                System.out.println("已找到该图书Ta在 "+(index+1)+" 的位置。");
+            }
+        }
+//    8.退出系统
+//在choiceMenu和main方法中完成退出系统
+    }
+
+
+
+```
\ No newline at end of file
diff --git "a/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.1.png" "b/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..0f2d1ffbea081bc38ec239e11cae10b4b4feeedd
Binary files /dev/null and "b/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.1.png" differ
diff --git "a/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.2.png" "b/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..25f37dfd72af0331521d56c828c639b8576d3ca0
Binary files /dev/null and "b/07 \345\206\257\345\273\272\347\250\213/Java\347\254\224\350\256\260\345\233\276\347\211\207\350\241\245\345\205\205/14.7.2.png" differ