diff --git "a/37 \347\216\213\346\231\264/2022.12.16\345\217\202\346\225\260.md" "b/37 \347\216\213\346\231\264/2022.12.16\345\217\202\346\225\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d98b95765c781b11640800739125312960db692a
--- /dev/null
+++ "b/37 \347\216\213\346\231\264/2022.12.16\345\217\202\346\225\260.md"	
@@ -0,0 +1,329 @@
+- ### 作业
+
+  .编写函数，计算圆的面积和周长，在主函数中接受圆的半径，在自定义函数中计算并输出
+
+```java
+import java.util.Scanner;
+
+public class c {
+    public static void main(String[] args) {
+        Scanner sc =new Scanner(System.in);
+        System.out.println("请输入圆的半径");
+        int r = sc.nextInt();
+        System.out.println("圆的周长是"+l(r));
+        System.out.println("圆的面积是"+s(r));
+    }
+    public static double l(int r){
+        return 2*r*3.14;
+    }
+    public static double s(int r){
+        return 3.14*r*r;
+    }
+}
+```
+
+
+
+在主函数中产生20个0-10之间的随机数，将这20个随机数存入数组，并通过函数计算某个数在这些随机数中出现的次数（这“某个数”是在主函数中由用户输入的）
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class c {
+    public static void main(String[] args) {
+        int[] arr =new int[20];
+        Random ran = new Random();
+        for ( int i=0;i<arr.length;i++){
+            int data= ran.nextInt(10);
+            arr[i]=data;
+            System.out.print(data+" ");
+        }
+        Scanner sc =new Scanner(System.in);
+        System.out.println();
+        System.out.println("请输入一个数");
+        int x =sc.nextInt();
+        sum(arr,x);
+    }
+public static void  sum(int[] arr ,int x){
+        int count =0;
+        for (int i=0;i< arr.length;i++){
+            if(x==arr[i]){
+                count++;
+            }
+        }
+    System.out.println("这个数出现的次数为"+count);
+    }
+}
+```
+
+用自定义函数是实现求某数组元素的和（大小不固定）
+
+```java
+import java.util.Random;
+
+public class c {
+    public static void main(String[] args) {
+               int[] arr=new int[10];
+        Random ran=new Random();
+        for ( int i=0;i<arr.length;i++){
+            int data= ran.nextInt(10);
+            arr[i]=data;
+            System.out.print(data+" ");
+        }
+        System.out.println();
+        System.out.println("这个数组的和为"+all(arr));
+        }
+        public  static int all(int[] arr){
+        int temp =0;
+            for (int i = 0; i < arr.length; i++) {
+                temp += arr[i];
+            }
+            return temp;
+
+        }
+
+ }
+```
+
+
+
+用户输入整数n，计算1!+(1!+2!)+(1!+2!+3!)+…..+(1!+2!+…n!)
+
+```java
+import java.util.Scanner;
+
+public class c {
+    public static void main(String[] args) {
+        Scanner sc =new Scanner(System.in);
+        System.out.println("请输入一个整数n");
+        int n =sc.nextInt();
+        System.out.println("这个公式的结果为："+result(n));
+    }
+public static int result(int a){
+        return a*(a+1)/2;
+}
+
+ }
+```
+
+ 在主函数中接收10个数存入数组，在自定义函数中，将该数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后在主函数中输出交换后的数组
+
+```java
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class c {
+    public static void main(String[] args) {
+                 int[] arr =new int [10];
+        Scanner sc=new Scanner(System.in);
+        for (int i = 0; i < 10; i++) {
+            System.out.println("请输入第"+(i+1)+"个数");
+            arr[i] = sc.nextInt();
+        }
+        System.out.println("数组为："+ Arrays.toString(arr));
+            R(arr);
+}
+public static void R(int [] arr){int max = arr[0];
+    int min = arr[0];
+    for (int i = 1; i < arr.length; i++) {
+        if (arr[i] > max) {
+            max = arr[i];
+        } else if (arr[i] < min) {
+            min = arr[i];
+        }
+    }
+    for (int i = 0; i < arr.length; i++) {
+        if (arr[i] == max) {
+            int t = arr[0];
+            arr[0] = max;
+            arr[i] = t;
+        }
+    }
+    for (int i = 0; i < arr.length; i++) {
+        if (arr[i] == min) {
+            int t = arr[arr.length - 1];
+            arr[arr.length - 1] = min;
+            arr[i] = t;
+        }
+    }
+    System.out.println("交换后，数组为："+Arrays.toString(arr));
+}
+ }
+```
+
+------
+
+- ### 笔记
+
+### 数据类型的探讨
+
+基本类型：最基础的一些常量。字面量这些，cpu 可以直接使用。
+
+基本数据类型，传递的是值本身。 int c =a; // c=5 
+
+##### 引用类型
+
+存放的是数据地址，传递给别的时候，传地址。地址就是变量在内存中的位置。
+
+```java
+int [] a={1,2,3} //001
+int [] b =a // b =a =001; a,b 都指向001，即 b是a的别称。
+```
+
+#### 返回值
+
+1. 无返回值 void
+
+2. 有返回值 int double string boolean等
+    也可以是数组等其它引1用类型
+
+3. 返回值用return关锤字返回，有返回值的方法，
+   —定要用return返回对应的类型的数捃
+
+4. return 类似 break,程序一旦执行完return语句，就立即返回方法调用的地方而不再执行return后面的代码
+
+   #### 参数
+
+   定义的地方叫形参,调用的地方叫实参
+
+   .1 无参数()
+   单个参数
+
+   ​     示例：（int a）
+   ​     语法（数据类型 參数名）
+
+   2. 多个参数
+       示例(int a, int b,......)
+       多个参数之间用，号隔开
+        注意多介参数，有順序的区別
+            兴型不同的顺序（重載）
+            同兴型，不同位置的使用
+
+      ### 方法调用
+
+      1.方法被调用前必须先定义
+      2.方法要被执行就一定要被调用
+      3.方法调用格式
+          示例：
+           getMax (1,2)
+
+      ​     语法：方法名(参数)；
+      4.方法之间可以互相调用，也就是方法里可以嵌套别的方法的调用
+      5.调用方法能不能传递参数
+      ​      一看定义方法时参数的个数
+      ​      二看类型
+      ​      三看顺序
+
+####  方法重载
+
+概念：指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
+
+-  多个方法在同一个类中
+
+-  多个方法具有相同的方法名 
+
+- 多个方法的参数不相同，类型不同或者数量不同
+
+  
+
+注意： 
+
+  重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式 。
+
+  重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值 来判定两个方法是否相互构成重载
+
+正确范例：
+
+```jav
+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) {
+         //方法体
+    }
+}
+```
+
+错误范例：
+
+```jav
+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方法*/
+        //方法体
+    }
+}
+```
+
+#### 方法参数传递基本类型
+
+```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;
+    }
+}
+```
+
+结论： 基本数据类型的参数，形式参数的改变，不影响实际参数 
+
+结论依据： 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
+
+#### 方法参数传递引用类型
+
+```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;
+   }
+}
+
+```
+
+结论： 对于引用类型的参数，形式参数的改变，影响实际参数的值
+
+ 结论依据： 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以 即使方法弹栈，堆内存中的数据也已经是改变后的结果