diff --git "a/06 \351\231\210\345\277\227\344\274\237/20221215 string\345\274\225\347\224\250\347\261\273\345\236\213.md" "b/06 \351\231\210\345\277\227\344\274\237/20221215 string\345\274\225\347\224\250\347\261\273\345\236\213.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a4fef3b4da5c5474afb79a769ef8b7d4ba16ced1
--- /dev/null
+++ "b/06 \351\231\210\345\277\227\344\274\237/20221215 string\345\274\225\347\224\250\347\261\273\345\236\213.md"	
@@ -0,0 +1,44 @@
+# 笔记
+
+```java
+int string
+```
+
+字符串是引用类型，但是字符串是比较特殊的引用类型，比如基本数据类型是直接赋值过去修改后原本的不会变，而引用类型是赋值地址过去修改后原本的也会变化，而string引用类型却是直接重新创建一个新的不会对赋值的进行修改。
+
+```java
+System.out.Println(Arrays.tostring(number));
+//这个也可以打印数组只不过这个是把数组变成一个字符串形式打印的所以不能修改
+```
+
+# 作业
+
+```java
+//输出一个倒过来的九九乘法表
+public class D1{
+    public static void main(String[] args) {
+        for(int i=9;i>=1;i--){
+            for(int j=i;j>=1;j--){
+                System.out.print(j + "x" + i + "=" + i*j + "\t");
+            }
+            System.out.println();
+        }
+    }
+}
+```
+
+```java
+//用445.40元购买了一百立方煤气，求煤气的二档，三档各占多少立方？其中：（一档0-240:3.375元/立；二档
+//241-360:4.05元/方；三档361-99999999:5.06元/方）
+public class D1{
+    public static void main(String[] args) {
+        for(int x=1;x<=100;x++){
+            if(x*4.05+(100-x)*5.06==445.40){
+                System.out.println("二档为" + x + "三档为" + (100-x));
+                break;
+            }
+        }
+    }
+}
+```
+
diff --git "a/06 \351\231\210\345\277\227\344\274\237/20221218 \346\226\271\346\263\225.md" "b/06 \351\231\210\345\277\227\344\274\237/20221218 \346\226\271\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..aa9c75ef3add7a71119fa9be80434e67462ac041
--- /dev/null
+++ "b/06 \351\231\210\345\277\227\344\274\237/20221218 \346\226\271\346\263\225.md"	
@@ -0,0 +1,195 @@
+# 笔记
+
+### 方法
+
+格式：
+
+```java
+public static 返回值 方法名(参数){	//public static 修饰符，目前先记住这个格式
+    方法体；	//返回值类型 方法操作完毕之后返回的数据的数据类型
+			  //如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
+}			 //方法名 调用方法时候使用的标识
+			//参数 由数据类型和变量名组成，多个参数之间用逗号隔开
+		   //方法体 完成功能的代码块
+		  // return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
+public static void 方法名 (参数1) {
+方法体;
+}
+public static void 方法名 (参数1, 参数2, 参数3...) {
+方法体;
+}//参数可以写很多
+```
+
+1、不带返回值
+
+```java
+public static void main(String[] args) {
+        isEvenNumber(10);
+}
+public static void isEvenNumber(int num){
+        if(num % 2 == 0){
+            System.out.println("偶数");
+        }else{
+            System.out.println("奇数");
+		}
+	}
+}//void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
+```
+
+2、带返回值
+
+```java
+public static void main(String[] args) {
+    System.out.println(getMax(10,20));
+    int result = getMax(10,20);
+    System.out.println(result);
+	for(int i = 1; i <= result; i++){
+        System.out.println("HelloWorld");
+	}
+}
+public static int getMax(int a, int b){
+        if(a > b){
+        	return a;
+        }else{
+        	return b;
+		}
+	}
+}
+```
+
+定义方法时，要做到两个明确
+
+​		明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
+
+​		明确参数：主要是明确参数的类型和数量
+
+调用方法时的注意：
+
+​		void类型的方法，直接调用即可
+
+​		非void类型的方法，推荐用变量接收调用
+
+## 方法重载
+
+方法重载概念：
+
+​	方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
+
+​			多个方法在同一个类中
+
+​			多个方法具有相同的方法名
+
+​			多个方法的参数不相同，类型不同或者数量不同
+
+​	注意：
+
+​			重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
+
+​			重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值
+
+来判定两个方法是否相互构成重载
+
+```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
+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;
+    }
+}
+//对于引用类型的参数，形式参数的改变，影响实际参数的值
+//引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果
+```
+
+
+
+# 作业
+
+```java
+import java.util.Scanner;
+
+public class q {
+    //定义一函数，用于求2个数中的较大数，并将其返回，这2个数字在主函数中由用户输入
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("输出两个数");
+        double shu1 = sc.nextDouble();
+        double shu2 = sc.nextDouble();
+        System.out.println(max(shu1,shu2));
+    }
+    public static double max(double a, double b) {
+        return a>b ? a:b;
+    }
+}
+```
+
+```java
+import java.util.Scanner;
+
+public class q {
+    //在主函数中从键盘接收X, Y , Z3个数，编写函数计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("输入X，Y，Z");
+        int X = sc.nextInt();
+        int Y = sc.nextInt();
+        int Z = sc.nextInt();
+        System.out.println(sum(X,Y,Z));
+    }
+    public static int sum(int X,int Y,int Z) {
+        return (X*X*X)+(Y*Y*Y)+(Z*Z*Z);
+    }
+}
+```
+