diff --git "a/08 \350\224\241\346\263\275\351\222\246/20221213 \344\275\234\344\270\232.md" "b/08 \350\224\241\346\263\275\351\222\246/20221213 \346\226\271\346\263\225\344\275\234\344\270\232.md"
similarity index 100%
rename from "08 \350\224\241\346\263\275\351\222\246/20221213 \344\275\234\344\270\232.md"
rename to "08 \350\224\241\346\263\275\351\222\246/20221213 \346\226\271\346\263\225\344\275\234\344\270\232.md"
diff --git "a/08 \350\224\241\346\263\275\351\222\246/20221215 \346\226\271\346\263\225\347\232\204\344\275\277\347\224\250.md" "b/08 \350\224\241\346\263\275\351\222\246/20221215 \346\226\271\346\263\225\347\232\204\344\275\277\347\224\250.md"
deleted file mode 100644
index 75db017ea87a8cf0a90603c09d9cb17ad0ad8de4..0000000000000000000000000000000000000000
--- "a/08 \350\224\241\346\263\275\351\222\246/20221215 \346\226\271\346\263\225\347\232\204\344\275\277\347\224\250.md"	
+++ /dev/null
@@ -1,50 +0,0 @@
-###  1.方法的总结
-
-- 方法有四种状态 无返回值,无参数  ; 有返回值,无参数, 无返回,有参数 ,有返回,也有参数
-- 调用方法前.一定要先定义这个方法.也就是说不能调用不存在的方法,否则报错
-- 有参数的方法,调用的时候使用的参数.称实参[具体有值],而定义方法时用的参数.称为形参,数据类型 参数名称(不具体的一个变量)
-- 有返回值的方法,返回的的类型由return决定,而且调用方法时,用一个变量接收,这个变量的类型.也要和调用的方法返回的类型一致
-
-### 2.作业
-
-1.作业
-
-~~~java
- public static void main(String[] args) {
-        //两个数比大小，用户来输入
-        Scanner sc1 = new Scanner(System.in);
-        Scanner sc2 = new Scanner(System.in);
-        System.out.println("请输入a的值");
-        int a = sc1.nextInt();
-        System.out.println("请输入b的值");
-        int b = sc2.nextInt();
-        System.out.println(bdx(a,b));
-
-    }
-    public static int bdx(int a ,int b){
-        int c=a > b ? a : b;
-        return c;
-    }
-~~~
-
-2.作业
-
-~~~java
- public static void main(String[] args) {
-        //键盘录入接收3个数x，y，z 编写函数计算3个数的立方并返回计算结果
-        Scanner sc1=new Scanner(System.in);
-        System.out.println("输入3个数");
-        double x = sc1.nextDouble();
-        Scanner sc2=new Scanner(System.in);
-        double y = sc2.nextDouble();
-        Scanner sc3=new Scanner(System.in);
-        double z = sc3.nextDouble();
-
-        System.out.println(max(x,y,z));
-
-    }
-    public static double max(double x,double y,double z){
-        double i=x*x+y*y+z*z;
-        return i;
-
-    }
\ No newline at end of file
diff --git "a/08 \350\224\241\346\263\275\351\222\246/20221215\345\205\263\344\272\216\346\226\271\346\263\225\347\232\204\347\254\224\350\256\260.md" "b/08 \350\224\241\346\263\275\351\222\246/20221215\345\205\263\344\272\216\346\226\271\346\263\225\347\232\204\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d9fa304d6e2bae01dc1acc180bdd1646c571d64b
--- /dev/null
+++ "b/08 \350\224\241\346\263\275\351\222\246/20221215\345\205\263\344\272\216\346\226\271\346\263\225\347\232\204\347\254\224\350\256\260.md"	
@@ -0,0 +1,287 @@
+
+
+## 方法
+
+### 1.方法的概念
+
+- 方法（method）：是将具有独立功能的代码组成一个整体，使其具有特殊功能得到代码集
+- 注意：
+  - 方法必须先创建才可以使用，该过程称为方法定义
+  - 方法创建后不可以直接运行，需要手动使用后才执行，该过程称为方法调用
+
+### 2.方法的定义与调用
+
+#### 1.无参数方法的定义和调用
+
+- 定义与调用的格式
+
+  ```java
+  //定义格式
+  public static void 方法名 ( ) {
+  	//方法体;
+  }
+  
+  //定义范例
+  public static void s1 ( ) {
+  	//方法体;
+  }
+  ```
+
+  ```java
+  //调用格式
+  方法名();
+  
+  //调用范例
+  s1();
+  ```
+
+- 注意
+
+  方法必须先定义再调用，否则程序将报错
+
+#### 2.带参数方法的定义和调用
+
+- 定义与调用的格式
+
+  ```java
+  //参数：由数据类型和变量名组成（数据类型 变量名）  参数范例：int a
+  //定义格式
+  public static void 方法名 (参数1) {
+  	//方法体;
+  }
+  
+  public static void 方法名 (参数1,参数2,参数3,...) {
+  	//方法体;
+  }
+  
+  //范例
+  public static void s1 (int number) {
+  	//方法体;
+  }
+  
+  public static void s1 (int num1,int num2,int num3) {
+  	//方法体;
+  }
+  ```
+
+  ```java
+  //调用格式
+  方法名 (参数);
+  
+  方法名(参数1,参数2);
+  
+  //范例
+  s1(10);
+  
+  s1(10,20,30);
+  ```
+
+- 注意
+
+  1. 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序都将报错
+  2. 方法定义时，多个参数之间使用 " , " 隔开
+  3. 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序报错
+
+#### 3.练习-判断奇偶数
+
+```java
+public class 判断奇偶数 {
+    public static void main(String[] args) {
+        number(10);
+    }
+    public static void number(int num){
+        if(num % 2 == 0){
+            System.out.println("偶数");
+        }else{
+            System.out.println("奇数");
+        }
+    }
+}
+```
+
+#### 4.带返回值方法的定义和调用
+
+- 定义与调用的格式
+
+  ```java
+  //格式
+  public static 数据类型 方法名 (参数) {
+  	reture 数据;
+  }
+  
+  //范例
+  public static boolean number(int num) {
+      return true;
+  }
+  public static int max(int a,int b){
+      return 100;
+  }
+  
+  ```
+
+  ```java
+  //调用格式
+  方法名 (参数);
+  数据类型 变量名 = 方法名 (参数);
+  
+  //范例
+  number(5);
+  booleam flag = number (5);
+  ```
+
+- 注：
+  1. 方法定义时return后面的值要与方法定义上的数据类型相匹配，否则程序报错
+  2. 方法返回值通常用于变量接收，否则该返回值将无意义
+
+#### 5.带返回值方法的练习
+
+```java
+//需求：设计一个方法可以获取两个数的较大值，数据来自于参数
+public class S4 {
+    public static void main(String[] args) {
+        System.out.println(getMax(10,20));
+    }
+    public static int getMax(int a, int b){
+        if (a > b){
+            return a;
+        }else{
+            return b;
+        }
+    }
+}
+```
+
+### 3.形参和实参
+
+1. 形参：方法定义中的参数，等同于变量定义格式，例：int number
+2. 实参：方法调用中的参数，等同于使用变量或常量，例： 10 number
+
+### 4.带参数方法的练习
+
+- 需求：设计一个方法(print)用于打印n到m之间所有的奇数
+
+- 代码：
+
+  ```java
+  public class S1 {
+      public static void main(String[] args) {
+          print(10,20);
+      }
+      public static void print(int n,int m){
+          System.out.print(n + "到" + m + "之间的奇数有：");
+          for (int i = n;i <= m;i++){
+              if (i %2 != 0){
+                  System.out.print(i + " ");
+              }
+          }
+      }
+  }
+  ```
+
+### 5.方法的通用格式
+
+- 格式：
+
+  ```java
+  public static 返回值类型 方法名(参数) {
+  	方法体;
+  	return 数据 ;
+  }
+  ```
+
+- 解释： 
+  - public static：修饰符，目前先记住这个格式
+  - 返回值类型：方法操作完毕之后返回的数据的数据类型 如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
+  - 方法名 调用方法时候使用的标识 参数 由数据类型和变量名组成，多个参数之间用逗号隔开 方法体 完成功能的代码块
+  - return：如果方法操作完毕，有数据返回，用于把数据返回给调用者
+- 定义方法时，要做到两个明确 ：
+  - 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果 有，写对应的数据类型
+  - 明确参数：主要是明确参数的类型和数量
+- 调用方法时的注意： 
+  - void类型的方法，直接调用即可
+  - 非void类型的方法，推荐用变量接收调用
+
+### 6.方法的注意事项
+
+- 方法不能嵌套定义
+
+  ```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语句后面不能跟数据或代码
+  	}
+  }
+  
+  ```
+
+### 7.总结
+
+- 方法有四种状态 无返回值,无参数  ; 有返回值,无参数, 无返回,有参数 ,有返回,也有参数
+- 调用方法前.一定要先定义这个方法.也就是说不能调用不存在的方法,否则报错
+- 有参数的方法,调用的时候使用的参数.称实参[具体有值],而定义方法时用的参数.称为形参,数据类型 参数名称(不具体的一个变量)
+- 有返回值的方法,返回的的类型由return决定,而且调用方法时,用一个变量接收,这个变量的类型.也要和调用的方法返回的类型一致
+
+### 8.作业
+
+##### 1.作业
+
+```java
+
+public static void main(String[] args) {
+        //两个数比大小，用户来输入
+        Scanner sc1 = new Scanner(System.in);
+        Scanner sc2 = new Scanner(System.in);
+        System.out.println("请输入a的值");
+        int a = sc1.nextInt();
+        System.out.println("请输入b的值");
+        int b = sc2.nextInt();
+        System.out.println(bdx(a,b));
+
+    }
+    public static int bdx(int a ,int b){
+        int c=a > b ? a : b;
+        return c;
+    }
+```
+
+##### 2.作业
+
+~~~java
+public static void main(String[] args) {
+        //键盘录入接收3个数x，y，z 编写函数计算3个数的立方并返回计算结果
+        Scanner sc1=new Scanner(System.in);
+        System.out.println("输入3个数");
+        double x = sc1.nextDouble();
+        Scanner sc2=new Scanner(System.in);
+        double y = sc2.nextDouble();
+        Scanner sc3=new Scanner(System.in);
+        double z = sc3.nextDouble();
+
+        System.out.println(max(x,y,z));
+
+    }
+    public static double max(double x,double y,double z){
+        double i=x*x*x+y*y*y+z*z*z;
+        return i;
+
+    }
\ No newline at end of file
diff --git "a/08 \350\224\241\346\263\275\351\222\246/20221216\346\226\271\346\263\225\347\232\204\351\207\215\350\275\275.md" "b/08 \350\224\241\346\263\275\351\222\246/20221216\346\226\271\346\263\225\347\232\204\351\207\215\350\275\275.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3de14257974416450d22ff356c2797c710e85d04
--- /dev/null
+++ "b/08 \350\224\241\346\263\275\351\222\246/20221216\346\226\271\346\263\225\347\232\204\351\207\215\350\275\275.md"	
@@ -0,0 +1,319 @@
+### 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方法*/
+		//方法体
+    }
+}
+~~~
+
+### 2.方法的参数传递
+
+##### 2.1方法参数传递基本类型
+~~~java
+package com.itheima.param;
+
+public class Test1 {
+	/*
+		方法参数传递为基本数据类型 :
+		
+				传入方法中的, 是具体的数值.
+	*/
+	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;
+	}
+}
+
+~~~
+
+- 结论：
+  -  基本数据类型的参数，形式参数的改变，不影响实际参数
+
+-  结论依据：
+  -  每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
+
+##### 2.2方法参数传递引用类型
+
+~~~java
+package com.itheima.param;
+
+public class Test2 {
+	/*
+		方法参数传递为引用数据类型 :
+			传入方法中的, 是内存地址.
+	*/
+	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;
+	}
+}
+
+~~~
+
+- 结论：
+  -  对于引用类型的参数，形式参数的改变，影响实际参数的值 
+
+- 结论依据：
+  -  引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以 即使方法弹栈，堆内存中的数据也已经是改变后的结果
+
+### 3.数组遍历
+~~~java
+package com.itheima.test;
+
+public class Test1 {
+	/*
+		需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22,33, 44, 55]
+		
+		思路：
+            1.定义一个数组，用静态初始化完成数组元素初始化
+            2.定义一个方法，对数组进行遍历
+            3.遍历打印的时候，数据不换行
+            4.调用遍历方法
+	*/
+	public static void main(String[] args) {
+		// 1.定义一个数组，用静态初始化完成数组元素初始化
+        int[] arr = {11, 22, 33, 44, 55};
+        // 4.调用遍历方法
+        printArray(arr);
+        System.out.println("另外一段代码逻辑 ");
+       }
+    
+	/*
+		2.定义一个方法，对数组进行遍历
+		
+        1, 参数 int[] arr
+        2, 返回值类型 void
+    */
+	public static void printArray(int[] arr){
+		System.out.print("[");
+		for (int i = 0; i < arr.length; i++) {
+			if(i == arr.length -1){
+				// 如果满足条件, 说明是最后一个元素, 最后一个元素, 特殊处理
+				System.out.println(arr[i] + "]");
+		}else{
+				// 3.遍历打印的时候，数据不换行
+				System.out.print(arr[i] + ", ");
+			}
+		}
+	}
+}
+
+~~~
+
+### 4.作业
+
+1.编写函数，计算圆的面积和周长，在主函数中接受圆的半径，在自定义函数中计算并输出
+
+~~~java
+public static void main(String[] args) {
+    Scanner r = new Scanner(System.in);
+    System.out.println("请输入这圆的半径：");
+    double a = r.nextDouble();
+    getS(a);
+    getL(a);
+}
+public static void  getS(double a){
+    double b = a*a;
+    System.out.println("这个圆的的面积为"+ b +"π");
+}
+public static void getL(double a){
+    double b = a*2;
+    System.out.println("这个圆的周长为"+ b +"π");
+}
+~~~
+
+2. 在主函数中产生20个0-10之间的随机数，将这20个随机数存入数组，并通过函数计算某个数在这些随机数中出现的次数（这“某个数”是在主函数中由用户输入的）
+
+~~~java
+    public static void main(String[] args) {
+        System.out.println("请输入一个0到10内的数则返回你该数出现的次数");
+        Scanner sc = new Scanner(System.in);
+        int j = sc.nextInt();
+        int[] aa = new int [20];
+        for(int i=0 ; i< aa.length; i++){
+            Random r = new Random();
+            int a = r.nextInt(11);
+            aa[i] = a;
+//            System.out.println(aa[i]);
+        }
+        System.out.println("这个数出现的次数为"+getNumber(j,aa));
+    }
+    public static int getNumber(int j,int[] aa){
+        int number = 0;
+        for(int i = 0;i<aa.length;i++){
+
+            if(j==aa[i]){
+                number++;
+            }
+        }
+        return number;
+    }
+~~~
+
+3.在主函数中接收10个数存入数组，在自定义函数中，将该数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后在主函数中输出交换后的数组
+
+~~~java
+  public static void main(String[] args) {
+        int[] aa = new int [10];
+        for(int i=0 ; i<aa.length;i++){
+            int a =sca();
+            aa[i] = a;
+        }
+
+        sort(aa);
+    }
+    //输入数据函数
+    public static int sca(){
+        Scanner sc = new Scanner(System.in);
+        int a = sc.nextInt();
+        return a;
+    }
+    public static void sort(int[] aa){
+
+        //找马克斯
+        int max = aa[0];
+        int maxb = 0;
+        for(int i = 1; i< aa.length;i++) {
+            if (max < aa[i]) {
+                max = aa[i];
+                maxb = i;
+            }
+        }
+
+        //max换位函数
+        int te;
+        te = aa[0];
+        aa[0] = max;
+        aa[maxb] = te;
+
+        //找迷你
+        int min = aa[0];
+        int minb =0;
+        for(int i = 1; i< aa.length;i++) {
+            if (min > aa[i]) {
+                min = aa[i];
+                minb = i;
+            }
+        }
+
+        //min换位
+        te = aa[aa.length-1];
+        aa[aa.length-1] = min;
+        aa[minb] = te;
+
+        //打印
+        for (int j = 0 ;j<aa.length;j++){
+            System.out.println(aa[j]);
+        }
+
+    }
+~~~
+
+4.用自定义函数是实现求某数组元素的和（大小不固定）
+
+~~~java
+ public static void main(String[] args) {
+        Random ran = new Random();
+        int arr[] = new int[5];
+        for (int i = 0 ; i < arr.length ; i ++) {
+            arr[i] = ran.nextInt(90)+10;
+        }
+        System.out.print("随机数组为：");
+        for (int i = 0 ; i < arr.length ; i ++) {
+            System.out.print(arr[i] + " ");
+        }
+        System.out.println();
+        System.out.println("该随机数组的和为：" + number(arr));
+    }
+    public static int number(int arr[]){
+        int num = 0;
+        for (int i = 0 ; i < arr.length ; i++) {
+            num += arr[i];
+        }
+        return num;
+    }
+
+~~~
+
+5.用户输入整数n，计算1!+(1!+2!)+(1!+2!+3!)+…..+(1!+2!+…n!)
+
+~~~java
+public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入n的值：");
+        double num = sc.nextInt();
+        System.out.println("1!+(1!+2!)+(1!+2!+3!)+…..+(1!+2!+…n!)=" + number(num));
+    }
+    public static double number(double num) {
+        double he = 0;
+        for (int i = 1 ; i <= num ; i ++) {
+            for (int j = 1 ; j <= i ; j ++) {
+                he += j;
+            }
+        }
+        return he;
+    }
\ No newline at end of file