docs: 更新20260720课堂笔记，同步代码变更——新增成员变量vs局部变量对比、对象引用与内存共享（Demo03）

README.md

@@ -41,5 +41,5 @@
 | 2026-07-15 | switch分支、循环结构与数组 | `c260715` | [默认包](./授课代码/c260715/src/) |
 | 2026-07-16 | 多维数组、forEach、Arrays工具类、三种排序算法（冒泡/选择/插入）与 Scanner 键盘输入 | `c260716` | [默认包](./授课代码/c260716/src/) |
 | 2026-07-17 | Java方法4种声明方式、数组作为方法参数、Random随机数类、在线OJ编码模板、三种排序算法复习、Scanner学生信息采集系统（BMI计算） | `c260717` | [默认包](./授课代码/c260717/src/) |
-| 2026-07-20 | 面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员、对象地址输出 | `c260720` | [默认包](./授课代码/c260720/src/) |
+| 2026-07-20 | 面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员、对象地址输出、成员变量 vs 局部变量、对象引用与内存共享 | `c260720` | [默认包](./授课代码/c260720/src/) |
 

授课代码/c260720/src/Demo03.java

@@ -0,0 +1,42 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2026/7/20
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        Teacher t1=new Teacher();   //t1 引用变量 执行 内存中的Teacher对象的地址，比如0x1024
+        t1.name="张三";
+        t1.sleep();
+        Teacher t2=t1;  //t2 引用变量 执行 内存中的Teacher对象的地址，也是0x1024
+        // t2做的所有操作，都是针对那个0x1024的地址对应的内存空间的。
+        t2.name="李四";
+        t2.id="1001";
+        t1.sleep();
+    }
+    /*
+    如果多个对象的引用是同一个空间，变量所记录的地址是一样的。
+    那么只要有一个对象修改了内存中的数据，无论其他哪一个对象，进行获取数据，都是修改后的数据。
+
+
+    成员变量和局部变量
+    类中的位置是不一样的：
+        成员变量是定义在【类内部，方法外部】
+        局部变量是定义在【方法内部】(方法的声明中的参数也算是内部)
+    内存中的位置是不一样的：
+        成员变量是在堆内存中
+        局部变量是在栈内存中
+    生命周期不同：
+        成员变量是随着对象的存在而存在，随着对象的消失而消失
+        局部变量是随着方法的调用而存在，随着方法的调用结束而消失。
+
+    初始化值不同：
+        成员变量有默认的初始化值，比如整数就是0，字符串就是null。
+        局部变量没有默认的初始化值，必须要先定义，初始化赋值才能使用
+
+     */
+
+
+}

授课代码/c260720/src/Teacher.java

@@ -9,11 +9,9 @@ public class Teacher {
     String id;
     String name;
     int age;
-
     public void teaching(){
         System.out.println(id+name+age+"在授课....");
     }
-
     public void sleep(){
         System.out.println(id+name+age+"在休息....");
     }

授课代码/c260720/src/TeacherTest.java

@@ -15,6 +15,9 @@ public class TeacherTest {
         t.age=25;
         t.teaching();
         t.sleep();
+
+
+
         System.out.println(t.name);
         System.out.println(t.age);
         System.out.println(t.id);

课堂笔记/01-JavaSE基础-笔记/20260720-笔记.md

@@ -64,8 +64,58 @@
 对象名.成员方法();   // 调用方法
 ```
 
+### 5. 成员变量（Member Variable）与局部变量（Local Variable）区别
+
+**文件**：`Demo03.java`
+
+| 对比维度 | 成员变量 | 局部变量 |
+|---------|---------|---------|
+| **类中位置** | 定义在【类内部，方法外部】 | 定义在【方法内部】（方法的参数也属于局部变量） |
+| **内存位置** | 堆内存（Heap）中 | 栈内存（Stack）中 |
+| **生命周期** | 随着对象的存在而存在，随着对象的消失而消失 | 随着方法的调用而存在，随着方法的调用结束而消失 |
+| **初始化值** | 有默认初始化值（整数→0，引用类型→`null`） | 没有默认初始化值，必须先定义赋值才能使用 |
+
+```java
+public class Student {
+    String name;  // 成员变量 —— 在类内部、方法外部
+    int age;      // 成员变量
+
+    public void study() {
+        String msg = "学习中";  // 局部变量 —— 在方法内部
+        System.out.println(msg);
+    }
+}
+```
+
 ---
 
+### 6. 对象引用与内存共享
+
+**文件**：`Demo03.java`
+
+当多个引用变量指向 **同一个内存地址** 时，它们操作的是同一块内存空间。任何一个引用修改了数据，其他引用获取到的都是修改后的数据。
+
+```java
+public class Demo03 {
+    public static void main(String[] args) {
+        Teacher t1 = new Teacher();  // t1 引用指向 0x1024
+        t1.name = "张三";
+        t1.sleep();                  // 输出：张三在休息....
+
+        Teacher t2 = t1;             // t2 也指向 0x1024（与 t1 同一对象）
+        t2.name = "李四";
+        t2.id = "1001";
+        t1.sleep();                  // 输出：1001李四在休息....（已被 t2 修改）
+    }
+}
+```
+
+> **图解**：`t1` 和 `t2` 是两个不同的引用变量，但存储的是同一个对象的地址 `0x1024`。通过 `t2.name = "李四"` 修改后，`t1.name` 也变成"李四"，因为它们是同一块内存。
+
+---
+
+
+
 ## 二、代码实战：类与对象完整示例
 
 ### 1. Student 学生类
@@ -230,13 +280,15 @@ public class TeacherTest {
 | 6 | 调用成员 | `对象名.成员变量` / `对象名.成员方法()` | `Demo02.java`, `TeacherTest.java` |
 | 7 | 多对象创建 | 一个类可创建多个独立对象 | `Demo02.java` |
 | 8 | 对象地址 | 直接输出对象得到 `类型@哈希码` | `TeacherTest.java` |
+| 9 | 成员变量 vs 局部变量 | 四维对比：位置、内存、生命周期、初始化值 | `Demo03.java` |
+| 10 | 对象引用与内存共享 | 多个引用指向同一内存地址，修改互相影响 | `Demo03.java` |
 
 ---
 
 ## 五、拓展阅读
 
-1. **堆与栈内存**：对象存储在堆（Heap）中，引用变量存储在栈（Stack）中
-2. **构造方法**：`new 类名()` 实际上是调用类的构造方法，默认有无参构造
-3. **封装性**：使用 `private` 关键字隐藏属性，通过 `getter/setter` 访问
-4. **this 关键字**：当成员变量与局部变量重名时，用 `this` 区分
-5. **匿名对象**：`new Student().study();` —— 没有名字的对象，用后即弃
+1. **构造方法**：`new 类名()` 实际上是调用类的构造方法，默认有无参构造
+2. **封装性**：使用 `private` 关键字隐藏属性，通过 `getter/setter` 访问
+3. **this 关键字**：当成员变量与局部变量重名时，用 `this` 区分
+4. **匿名对象**：`new Student().study();` —— 没有名字的对象，用后即弃
+5. **null 与 NullPointerException**：引用变量可以不指向任何对象（`null`），调用该引用的成员会报空指针异常