diff --git "a/25 \346\234\261\346\203\240\345\277\240/20221212 \346\225\260\347\273\2042.md" "b/25 \346\234\261\346\203\240\345\277\240/20221212 \346\225\260\347\273\2042.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d7c67d247f6550351ec4e389dc839a86fc320bde
--- /dev/null
+++ "b/25 \346\234\261\346\203\240\345\277\240/20221212 \346\225\260\347\273\2042.md"	
@@ -0,0 +1,114 @@
+## 数组
+
+
+
+1.数组的常用定义格式
+
+```java
+int[] arr;
+double[] arr;
+char[] arr;
+```
+
+2.数组的动态初始化
+
+格式
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度]
+int[] arr = new int[3];
+```
+
+3.动态初始化格式详解
+
+等号左边：
+
+int:数组的数据类型
+
+[]:代表这是一个数组
+
+arr:代表数组的名称
+
+等号右边：
+
+new:为数组开辟内存空间
+
+int:数组的数据类型
+
+[]:代表这是一个数组
+
+5:代表数组的长度
+
+4.数组元素访问
+
+访问数组元素格式
+
+```java
+数组名[索引];
+```
+
+什么是索引
+
+每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
+
+5.数组的静态初始化
+
+什么是静态初始化
+
+在创建数组时，直接将元素确定
+
+静态初始化格式
+
+```java
+数据类型[] 数组名 = {元素1,元素2,...};
+```
+
+6.数组遍历
+
+数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+
+## 作业
+
+```java
+import java.util.Arrays;
+import java.util.Random;
+
+public class a {
+    public static void main(String[] args) {
+        //闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，
+        // 存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分
+        // 【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】，
+        int[] arr = new int[10];
+        int sum = 0;
+        Random r = new Random();
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = r.nextInt(100) + 1;
+            sum += arr[i];
+        }
+        System.out.println(Arrays.toString(arr));
+        int max = arr[0];
+        int min = arr[0];
+        for (int i = 1; i < arr.length; i++) {
+            if (max < arr[i]) {
+                max = arr[i];
+            }
+            if (min > arr[i]) {
+                min = arr[i];
+            }
+        }
+        System.out.println("总分："+ sum);
+        System.out.println("最大值："+ max);
+        System.out.println("最小值："+ min);
+        double a = (sum-max-min)*1.0/(arr.length-2);
+        System.out.println("平均值为："+ a);
+    }
+}
+```
+
+```
+int[] arr;
+double[] arr;
+char[] arr;
+```
\ No newline at end of file
diff --git "a/25 \346\234\261\346\203\240\345\277\240/20221213 \345\244\215\344\271\240.md" "b/25 \346\234\261\346\203\240\345\277\240/20221213 \345\244\215\344\271\240.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e8e5728f5c9a5e144fd0a2365561f8f8d4be6c67
--- /dev/null
+++ "b/25 \346\234\261\346\203\240\345\277\240/20221213 \345\244\215\344\271\240.md"	
@@ -0,0 +1,79 @@
+1.\n表示换行，\t制表符，相当于大空格table，也会是缩进对齐
+
+2整数类型
+
+     1.基本数据类型（CPU可以直接拿来运算的一些数据）
+    
+        整数型：  整数 、小数、字符、
+    
+          非数值型：boolean true false
+    
+       2、引用数据类型
+    
+        String  数组 
+    
+     计算不能直接把这些数据拿来运算，因为引用数据类型的变量，存放的其实就是数据类型的地址，
+    
+     而不是实际上的数据，要访问具体的数据就需要用到引用类型自己的一些方法
+
+3.字符串的比较为什么要用equals
+
+例：
+
+```java
+String psw = "abc";
+String userpsd = new String("abc");
+if(psd.equals(userpsd)){
+    sout()
+}
+```
+
+equals的使用就是先找到内存地址所在的位置，再取出里面的数据进行比较
+
+4. String虽然是引用数据类型，但是“ ”直接赋值出来的字符中很特殊
+
+   可以直接当基本数据类型使用，比如输出和比较。
+
+   但它本身不是数值型，不能做算术运算
+
+   5.字符串
+
+   输出的时候是字符，但是比较的时候是内存地址
+
+   ## 作业
+
+   ```java
+   public class D5 {
+       //用倒序输出乘法口诀，9到1
+           public static void main(String[] args) {
+               //表示行
+               for (int i=9; i>=1; i--){
+                   //表示列
+                   for (int j=1; j<=i; j++){
+                       System.out.print(j+"*"+i+"="+j*i+"\t");
+                   }
+                   System.out.println();
+               }
+           }
+       }
+   
+   
+   
+   
+   public class D3 {
+       //计算燃气
+       public static void main(String[] args) {
+           //购买100立方 总共付了445.4元
+           //第二档4.05元/立方,第三档5.06元/立方
+           //求购买的第二档和第三档分别为多少？
+           for (int i =1;i<100;i++){
+               if (i*4.05+(100-i)*5.06 ==445.4){
+                   System.out.println("第二档"+i+"立方，"+"第三档"+(100-i)+"立方");
+               }
+           }
+       }
+   }
+   
+   ```
+
+   
\ No newline at end of file
diff --git "a/25 \346\234\261\346\203\240\345\277\240/20221215 \346\226\271\346\263\225.md" "b/25 \346\234\261\346\203\240\345\277\240/20221215 \346\226\271\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..49048f4a2b86d585f24d49d81f38ce7030c37e48
--- /dev/null
+++ "b/25 \346\234\261\346\203\240\345\277\240/20221215 \346\226\271\346\263\225.md"	
@@ -0,0 +1,124 @@
+## 方法
+
+### 1.方法的概念
+
+- 方法（method）：是将具有独立功能的代码组成一个整体，使其具有特殊功能得到代码集
+- 注意：
+  - 方法必须先创建才可以使用，该过程称为方法定义
+  - 方法创建后不可以直接运行，需要手动使用后才执行，该过程称为方法调用
+
+### 2.方法的定义与调用
+
+#### 1.无参数方法的定义和调用
+
+- 定义与调用的格式
+
+  ```
+  //定义格式
+  public static void 方法名 ( ) {
+  	//方法体;
+  }
+  
+  //定义范例
+  public static void s1 ( ) {
+  	//方法体;
+  }
+  ```
+
+  ```
+  //调用格式
+  方法名();
+  
+  //调用范例
+  s1();
+  ```
+
+- 注意
+
+  方法必须先定义再调用，否则程序将报错
+
+#### 2.带参数方法的定义和调用
+
+- 定义与调用的格式
+
+  ```
+  //参数：由数据类型和变量名组成（数据类型 变量名）  参数范例：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) {
+  	//方法体;
+  }
+  ```
+
+  ```
+  //调用格式
+  方法名 (参数);
+  
+  方法名(参数1,参数2);
+  
+  //范例
+  s1(10);
+  
+  s1(10,20,30);
+  ```
+
+- 注意
+
+  1. 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序都将报错
+  2. 方法定义时，多个参数之间使用 " , " 隔开
+  3. 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序报错
+
+
+
+### 3.作业
+
+```
+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;
+    }
+```
+
+```
+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/25 \346\234\261\346\203\240\345\277\240/20221216 \345\217\202\346\225\260.md" "b/25 \346\234\261\346\203\240\345\277\240/20221216 \345\217\202\346\225\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4b6e131bb360d2d6dd9bf05f148cbe790bce34e9
--- /dev/null
+++ "b/25 \346\234\261\346\203\240\345\277\240/20221216 \345\217\202\346\225\260.md"	
@@ -0,0 +1,211 @@
+###      1.形参和实参
+
+1. 形参：方法定义中的参数
+
+   等同于变量定义格式，例：int number
+
+2. 实参：方法调用中的参数
+
+   等同于使用变量或常量，例： 10 numbe
+
+   ### 2.方法的通用格式（掌握）
+
+    格式：
+
+   ``` java
+   public static 返回值类型 方法名(参数) {
+   方法体;
+   return 数据 ;
+   }
+   1
+   ```
+
+   
+
+    解释： public static 修饰符，目前先记住这个格式 返回值类型 方法操作完毕之后返回的数据的数据类型 
+
+   如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return 
+
+   方法名 调用方法时候使用的标识 
+
+   参数 由数据类型和变量名组成，多个参数之间用逗号隔开 
+
+   方法体 完成功能的代码块
+
+    return 如果方法操作完毕，有数据返回，用于把数据返回给调用者 定义方法时，要做到两个明确
+
+   明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果 有，写对应的数据类型 
+
+   明确参数：主要是明确参数的类型和数量 调用方法时的注意： 
+
+   void类型的方法，直接调用即可 
+
+   非void类型的方法，推荐用变量接收调用
+
+#### 3.作业
+
+1.编写函数，计算圆的面积和周长，在主函数中接受圆的半径，在自定义函数中计算并输出
+
+```
+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 +"π");
+}
+```
+
+1. 在主函数中产生20个0-10之间的随机数，将这20个随机数存入数组，并通过函数计算某个数在这些随机数中出现的次数（这“某个数”是在主函数中由用户输入的）
+
+```
+    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个数存入数组，在自定义函数中，将该数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后在主函数中输出交换后的数组
+
+```
+  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.用自定义函数是实现求某数组元素的和（大小不固定）
+
+```
+import java.util.Random;
+
+public class D31 {
+    public static void main(String[] args) {
+        //用自定义函数是实现求某数组元素的和（大小不固定）
+        int[] num = new  int[10];
+        Random ran = new Random();
+        for (int i =1 ; i< num.length ; i++){
+            num[i] = ran.nextInt(101);
+        }
+        System.out.println("生成的数组如下：");
+        for (int a:num){
+            System.out.print(a + "\t");
+        }
+        System.out.println();
+        Sum(num);
+    }
+    public static void Sum(int[] num){
+        int sum = 0;
+        for (int i = 0 ; i< num.length ; i++){
+            sum += num[i];
+        }
+        System.out.println("元素和为：" + sum);
+    }
+}
+```
+
+5.用户输入整数n，计算1!+(1!+2!)+(1!+2!+3!)+…..+(1!+2!+…n!)
+
+```
+import java.util.Scanner;
+
+public class D999 {
+    public static void main(String[] args) {
+        //用户输入整数n，计算1!+(1!+2!)+(1!+2!+3!)+…..+(1!+2!+…n!)
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请你输入一个整数：");
+        int yongHu = sc.nextInt();
+        int sum = 0;
+        for (int i=1 ; i<=yongHu ; i++){
+            for (int j=1 ;j<=i ; j++){
+                sum += Sum(j);
+            }
+        }
+        System.out.println("计算结果为：" + sum);
+    }
+    public static int Sum(int a){
+        int sum = 1;
+        for (int i = 1;i<=a;i++){
+            sum*=i;
+        }
+        return sum;
+    }
+}
+```
\ No newline at end of file