docs: 更新20260722课堂笔记，同步代码变更——新增继承中变量就近原则、this vs super完整对比、构造方法继承特点（super()默认调用/父类无无参构造处理）

README.md

@@ -29,7 +29,7 @@
 | 2026-07-17 | [Java方法4种声明方式（无参无返回值/有参无返回值/有参有返回值/无参有返回值）、方法中调用方法、数组作为方法参数、Random随机数类、Random+方法综合练习、三种排序算法复习、Scanner 学生信息采集系统](./课堂笔记/01-JavaSE基础-笔记/20260717-笔记.md) |
 | 2026-07-20 | [面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员](./课堂笔记/01-JavaSE基础-笔记/20260720-笔记.md) |
 | 2026-07-21 | [构造方法（构造器）：构造方法引出、格式与特点、默认构造方法、无参构造方法、构造方法重载、有参构造方法调用、this 在构造方法中的应用、private 构造方法阻止外部创建对象、完整 Person 示例（4种构造方法重载）、课后作业回顾（Fisher-Yates 洗牌算法/Emp 员工封装/MathTools 回文数/Student 封装展示）](./课堂笔记/01-JavaSE基础-笔记/20260721-笔记.md) |
-| 2026-07-22 | [继承：继承的概念、格式、好处与弊端、is...a 使用场景、方法重写（@Override）、super 关键字调用父类成员、同名属性处理（this vs super）、单继承与多层继承、Object 根类、访问修饰符在继承中的体现、随堂练习（学生成绩管理系统-构造方法版）、课后作业（猜数游戏面向对象版/BookManager图书管理系统）](./课堂笔记/01-JavaSE基础-笔记/20260722-笔记.md) |
+| 2026-07-22 | [继承：继承的概念、格式、好处与弊端、is...a 使用场景、方法重写（@Override）、super 关键字调用父类成员、同名属性处理（this vs super）、变量的就近原则查找、this vs super 完整对比、继承中构造方法特点（子类默认调用 super()、父类无无参构造时的处理）、单继承与多层继承、Object 根类、访问修饰符在继承中的体现、随堂练习（学生成绩管理系统-构造方法版）、课后作业（猜数游戏面向对象版/BookManager图书管理系统）](./课堂笔记/01-JavaSE基础-笔记/20260722-笔记.md) |
 
 ## 二、授课代码
 
@@ -45,7 +45,7 @@
 | 2026-07-17 | Java方法4种声明方式、数组作为方法参数、Random随机数类、在线OJ编码模板、三种排序算法复习、Scanner学生信息采集系统（BMI计算） | `c260717` | [默认包](./授课代码/c260717/src/) |
 | 2026-07-20 | 面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员、对象地址输出、成员变量 vs 局部变量、对象引用与内存共享、对象数组、循环创建对象并存入数组、多个类协同建模（古诗场景/交通场景）、封装（private/setter/getter/this关键字/权限修饰符）、包（Package）声明与同包访问、方法返回对象数组、综合应用（学生管理+随机抽取） | `c260720` | [`p1`](./授课代码/c260720/src/p1/) / [`p2`](./授课代码/c260720/src/p2/) |
 | 2026-07-21 | 构造方法（构造器）：构造方法概念与格式、默认构造方法、构造方法重载、有参构造方法、private 构造方法、this 关键字在构造方法中的应用、随堂练习（Cat/Dog/Book/Phone/单例Manager）、Fisher-Yates 洗牌算法（数组随机打乱）、封装与 setter 校验复习、回文数判断算法 | `c260721` | [`course`](./授课代码/c260721/src/course/) / [`homework/c260717`](./授课代码/c260721/src/homework/c260717/) / [`homework/c260720`](./授课代码/c260721/src/homework/c260720/) / [`exercise/exercise01`](./授课代码/c260721/src/exercise/exercise01/) / [`exercise/exercise02`](./授课代码/c260721/src/exercise/exercise02/) |
-| 2026-07-22 | 继承（extends）的概念、格式、好处与弊端、is...a 使用场景、方法重写（Override）、super 关键字、同名属性处理、单继承与多层继承（Animal→Bird→Penguin / Granddad→Dad→Son）、访问修饰符在继承中的体现、随堂练习（学生成绩管理系统-构造方法版/对象数组/冒泡排序）、课后作业（GuessGame 猜数游戏面向对象版/BookManager 图书管理系统） | `c260722` | [`course`](./授课代码/c260722/src/course/) / [`exercise/studentSystem`](./授课代码/c260722/src/exercise/studentSystem/) / [`homework/p08_guessgame`](./授课代码/c260722/src/homework/p08_guessgame/) / [`homework/p09_bookmanager`](./授课代码/c260722/src/homework/p09_bookmanager/) |
+| 2026-07-22 | 继承（extends）的概念、格式、好处与弊端、is...a 使用场景、方法重写（Override）、super 关键字、同名属性处理、变量的就近原则查找、this vs super 对比、继承中构造方法特点（子类默认调用 super()、父类无无参构造时的处理）、单继承与多层继承（Animal→Bird→Penguin / Granddad→Dad→Son）、访问修饰符在继承中的体现、随堂练习（学生成绩管理系统-构造方法版/对象数组/冒泡排序）、课后作业（GuessGame 猜数游戏面向对象版/BookManager 图书管理系统） | `c260722` | [`course`](./授课代码/c260722/src/course/) / [`exercise/studentSystem`](./授课代码/c260722/src/exercise/studentSystem/) / [`homework/p08_guessgame`](./授课代码/c260722/src/homework/p08_guessgame/) / [`homework/p09_bookmanager`](./授课代码/c260722/src/homework/p09_bookmanager/) |
 
 ## 三、课堂练习题
 

授课代码/c260722/src/course/Animal.java

@@ -10,7 +10,9 @@ package course;
  */
 public class Animal{
 
-
+    public Animal() {
+        System.out.println("动物类的无参构造方法");
+    }
 
     public void eat(){
         System.out.println("吃......");

授课代码/c260722/src/course/Dad.java

@@ -9,6 +9,7 @@ package course;
  * @create 2026/7/22
  */
 public class Dad extends Granddad{
+    int c;
     public void eat(){
         super.eat();
         System.out.println("爸爸爱吃肉....");

授课代码/c260722/src/course/Demo02.java

@@ -0,0 +1,55 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2026/7/22
+ */
+public class Demo02 {
+    /*
+     继承中变量的访问特点：
+     在子类中访问一个变量，采用的是就近原则：
+        1、在子类的局部范围查找
+        2、在子类的成员范围查找
+        3、父类的成员范围查找，包括父类的父类
+        4、如果都没有就报错
+
+     super关键字
+     之前我们说过this关键字，指向的是本类的对象。
+     super执行的就是本类的父类的对象。
+     this 代表本类对象的引用
+     super 代表父类对象的引用
+
+     this和super的使用：
+        成员变量中：
+            this.成员变量  --> 访问本类的成员变量
+            super.成员变量 --> 访问父类的成员变量
+        成员方法中：
+            this.成员方法  --> 访问本类的成员方法
+            super.成员方法 --> 访问父类的成员方法
+        构造方法中：
+            this()      --> 访问本类的无参构造方法
+            this(参数)   --> 访问本类的有参构造方法
+            super()      --> 访问父类的无参构造方法
+            super(参数)   --> 访问父类的有参构造方法
+
+     继承中的构造方法的特点：
+        子类的所有构造方法（有参的或无参）都会默认访问父类的【无参构造方法】。
+        如果父类没有无参的构造方法，那么就必须在子类的构造方法中指定父类的某一个有参构造方法。
+        指定方式 就是 super(参数)
+
+      子类会继承父类的数据，可能还会使用父类的数据，所以，子类在初始化（创建对象之前），
+      就一定要先完成对父类对象的创建。原因就是每一个子类构造方法的【第1句】默认都是 super() 就是调用父类的无参构造方法。
+
+
+        当创建子类对象的时候，一定会先加载父类的构造方法（默认加载无参的，没有就加载子类构造方法中指定调用的）
+        再完成子类对象的创建。
+
+     */
+
+
+
+}

授课代码/c260722/src/course/Dog.java

@@ -0,0 +1,13 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description
+ * @create 2026/7/22
+ */
+public class Dog extends Animal{
+
+}

授课代码/c260722/src/course/Fu.java

@@ -0,0 +1,25 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Fu
+ * @description
+ * @create 2026/7/22
+ */
+public class Fu {
+    private String name;
+
+    //父类的有参构造方法替换了默认的无参构造方法
+    //父类没有无参构造方法了
+    public Fu(String name) {
+        this.name = name;
+    }
+
+    //即使父类有无参构造方法，但是是私有的
+    //子类依旧无法调用
+    public  Fu(){
+
+    }
+}

授课代码/c260722/src/course/Granddad.java

@@ -9,6 +9,7 @@ package course;
  * @create 2026/7/22
  */
 public class Granddad {
+    int d;
     public void eat(){
         System.out.println("爷爷爱喝酒....");
     }

授课代码/c260722/src/course/Person.java

@@ -0,0 +1,26 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description 父类
+ * @create 2026/7/22
+ */
+public class Person {
+    private String name;
+    private Integer age;
+
+    public Person(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public void eat(){
+        System.out.println("吃饭");
+    }
+    public void sleep(){
+        System.out.println("睡觉");
+    }
+}

授课代码/c260722/src/course/Son.java

@@ -9,8 +9,16 @@ package course;
  * @create 2026/7/22
  */
 public class Son extends Dad{
+    int a;
+    int b;
+
     public void eat(){
+        int a=10;
         super.eat();//调用自己父类
         System.out.println("儿子不吃饭....");
+        System.out.println(a);  //从子类的局部范围查找
+        System.out.println(b);  //从子类的成员范围查找
+        System.out.println(c);  //从父类的成员范围查找
+        System.out.println(d);  //从父类的父类的成员范围查找
     }
 }

授课代码/c260722/src/course/Student.java

@@ -0,0 +1,22 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description
+ * @create 2026/7/22
+ */
+public class Student extends Person{
+    private String school;
+    //因为父类没有了无参构造方法，
+    //代码找不到父类无参构造方法了，所以程序自动报错。
+    //为了解决这个错误，我们要给他指定一个父类有参构造方法
+    public Student(String name, Integer age,String school) {
+        //为了解决我们在子类的构造方法中，
+        //调用父类的有参构造方法，并且把参数传入进去。
+        super(name,age);
+        this.school=school;
+    }
+}

授课代码/c260722/src/course/Test03.java

@@ -0,0 +1,16 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Test03
+ * @description
+ * @create 2026/7/22
+ */
+public class Test03 {
+    public static void main(String[] args) {
+        Dog d=new Dog();
+
+    }
+}

授课代码/c260722/src/course/Zi.java

@@ -0,0 +1,19 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Zi
+ * @description
+ * @create 2026/7/22
+ */
+public class Zi extends Fu{
+    public Zi(){
+        //由于父类没有无参的构造方法，
+        //子类没办法调用父类默认的无参构造方法
+        //就需要我们自己调用父类的有参构造方法，并且传入参数，否则会报错。
+        super();
+        System.out.println("ghhhh");
+    }
+}

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

@@ -404,6 +404,210 @@ public class Bird extends Animal {
 }
 ```
 
+### 13. 继承中变量的访问特点——就近原则
+
+**文件**：`Demo02.java`、`Son.java`
+
+在子类中访问一个变量时，采用 **就近原则** 查找：
+
+| 查找顺序 | 查找范围 | 示例（Son 中访问 `a`） |
+|:--------:|---------|----------------------|
+| 1️⃣ | 子类的 **局部范围**（方法内部） | `int a = 10;`（局部变量） |
+| 2️⃣ | 子类的 **成员范围**（成员变量） | `int a;`（子类成员变量） |
+| 3️⃣ | **父类** 的成员范围 | `int c;`（Dad 的成员变量） |
+| 4️⃣ | **父类的父类**……直到 Object | `int d;`（Granddad 的成员变量） |
+| ❌ | 如果都没找到 | 编译报错 |
+
+```java
+// Son.java —— 演示就近原则
+public class Son extends Dad {
+    int a;          // 子类的成员变量（第2层）
+    int b;          // 子类的成员变量（第2层）
+
+    public void eat() {
+        int a = 10;   // 局部变量（第1层）
+        super.eat();
+
+        System.out.println(a);  // 10  —— 局部范围找到 a
+        System.out.println(b);  // 0   —— 局部无 b → 子类成员找到 b
+        System.out.println(c);  // 0   —— 子类无 c → 父类 Dad 找到 c
+        System.out.println(d);  // 0   —— 父类无 d → 祖父 Granddad 找到 d
+    }
+}
+
+// Granddad.java —— 顶层父类定义了 d
+public class Granddad {
+    int d;
+    public void eat() {
+        System.out.println("爷爷爱喝酒....");
+    }
+}
+
+// Dad.java —— 父类定义了 c
+public class Dad extends Granddad {
+    int c;
+    public void eat() {
+        super.eat();
+        System.out.println("爸爸爱吃肉....");
+    }
+}
+```
+
+> **总结**：变量的查找路径为 **局部 → 本类成员 → 父类成员 → 祖父类成员 → … → Object**。如果一直找到 Object 都没有，则编译报错。
+
+---
+
+### 14. this vs super 完整对比
+
+**文件**：`Demo02.java`
+
+`this` 和 `super` 是 Java 中两个非常重要的关键字：
+
+| 关键字 | 含义 | 示例 |
+|--------|------|------|
+| `this` | 代表 **本类** 对象的引用 | `this.name`、`this.eat()`、`this()` |
+| `super` | 代表 **父类** 对象的引用 | `super.name`、`super.eat()`、`super()` |
+
+**在三种场景中的使用对比**：
+
+| 场景 | `this` 用法 | `super` 用法 |
+|------|------------|-------------|
+| **成员变量** | `this.成员变量` —— 访问本类的成员变量 | `super.成员变量` —— 访问父类的成员变量 |
+| **成员方法** | `this.成员方法()` —— 调用本类的成员方法 | `super.成员方法()` —— 调用父类的成员方法 |
+| **构造方法** | `this()` / `this(参数)` —— 调用本类的其他构造方法 | `super()` / `super(参数)` —— 调用父类的构造方法 |
+
+```java
+// Demo02.java（注释中总结）
+/*
+this 代表本类对象的引用
+super 代表父类对象的引用
+
+成员变量中：
+    this.成员变量  --> 访问本类的成员变量
+    super.成员变量 --> 访问父类的成员变量
+成员方法中：
+    this.成员方法  --> 调用本类的成员方法
+    super.成员方法 --> 调用父类的成员方法
+构造方法中：
+    this()      --> 访问本类的无参构造方法
+    this(参数)   --> 访问本类的有参构造方法
+    super()      --> 访问父类的无参构造方法
+    super(参数)   --> 访问父类的有参构造方法
+*/
+```
+
+> **注意**：`this()` 和 `super()` 都必须写在构造方法的 **第一行**，且不能同时出现。
+
+---
+
+### 15. 继承中构造方法的特点
+
+**文件**：`Demo02.java`、`Animal.java`、`Dog.java`、`Test03.java`、`Fu.java`、`Zi.java`、`Person.java`、`Student.java`
+
+#### 15.1 子类构造方法默认调用父类无参构造
+
+**文件**：`Animal.java`、`Dog.java`、`Test03.java`
+
+子类的所有构造方法（有参或无参）都会 **默认调用父类的无参构造方法**。每个子类构造方法的 **第一句** 默认都是 `super()`。
+
+```java
+// Animal.java —— 父类：添加无参构造方法打印信息
+public class Animal {
+    public Animal() {
+        System.out.println("动物类的无参构造方法");
+    }
+}
+
+// Dog.java —— 子类：没有写任何构造方法，默认有无参构造
+public class Dog extends Animal {
+    // 隐藏的默认构造方法：
+    // public Dog() {
+    //     super();  // 自动调用父类的无参构造
+    // }
+}
+
+// Test03.java —— 测试
+public class Test03 {
+    public static void main(String[] args) {
+        Dog d = new Dog();
+    }
+}
+```
+
+**输出结果**：
+```
+动物类的无参构造方法
+```
+
+> **原理**：子类在初始化（创建对象）之前，一定要先完成对父类对象的创建。因为子类会继承父类的数据，可能还会使用父类的数据，所以必须先创建父类对象。这就是为什么每个子类构造方法的第一句默认都是 `super()`。
+
+#### 15.2 父类没有无参构造时的处理
+
+**文件**：`Fu.java`、`Zi.java`、`Person.java`、`Student.java`
+
+**情况一**：父类 **没有** 无参构造方法（只有有参构造），子类必须手动调用父类的有参构造。
+
+```java
+// Fu.java —— 父类：只有有参构造
+public class Fu {
+    private String name;
+
+    public Fu(String name) {   // 有参构造覆盖了默认无参构造
+        this.name = name;
+    }
+}
+
+// Zi.java —— 子类：必须手动调用父类的有参构造
+public class Zi extends Fu {
+    public Zi() {
+        super("默认名");  // ❗ 必须手动调用父类的有参构造，否则编译报错
+        System.out.println("子类构造方法");
+    }
+}
+```
+
+**情况二**：父类 **有无参构造但被 private 修饰**，子类也无法调用。
+
+```java
+// Fu.java —— 父类有无参构造但是 private
+// private Fu() { }   // private 构造方法，子类不可见
+```
+
+#### 15.3 综合示例：Person → Student
+
+**文件**：`Person.java`、`Student.java`
+
+```java
+// Person.java —— 父类只有有参构造
+public class Person {
+    private String name;
+    private Integer age;
+
+    public Person(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+}
+
+// Student.java —— 子类必须手动调用 super(name, age)
+public class Student extends Person {
+    private String school;
+
+    public Student(String name, Integer age, String school) {
+        super(name, age);    // 调用父类的有参构造，传入参数
+        this.school = school;
+    }
+}
+```
+
+> **核心规则**：
+> 1. 子类构造方法 **默认第一句** 是 `super()`（调用父类无参构造）
+> 2. 如果父类 **没有无参构造**，子类必须通过 `super(参数)` 指定调用父类的有参构造
+> 3. 如果父类 **有无参构造但是 private**，子类同样无法调用，也需要指定其他构造
+> 4. `super(参数)` 必须在子类构造方法的 **第一行**
+
+---
+
 **包名**：`exercise.studentSystem`
 
 ### 题目要求
@@ -688,6 +892,10 @@ public class BookManagerTest {
 | **@Override 注解** | ⭐⭐⭐⭐ | 可选的检查注解，推荐加上帮助编译器校验 |
 | **super 关键字** | ⭐⭐⭐⭐⭐ | `super.方法()` 调用父类方法，`super.属性` 访问父类属性 |
 | **同名属性处理** | ⭐⭐⭐⭐ | 父子类同名属性同时存在，`this` 访问自己的，`super` 访问父类的 |
+| **变量的就近原则** | ⭐⭐⭐⭐⭐ | 变量查找路径：局部 → 本类成员 → 父类成员 → 祖父类成员 → Object |
+| **this vs super 对比** | ⭐⭐⭐⭐ | `this`=本类引用，`super`=父类引用，在变量/方法/构造方法三场景对比 |
+| **构造方法继承特点** | ⭐⭐⭐⭐⭐ | 子类构造方法默认第一句 `super()` 调用父类无参构造 |
+| **父类无无参构造处理** | ⭐⭐⭐⭐⭐ | 父类无无参构造时，子类必须手动 `super(参数)` 指定有参构造 |
 | **单继承** | ⭐⭐⭐⭐⭐ | Java 一个子类只能有一个直接父类 |
 | **多层继承** | ⭐⭐⭐⭐ | 支持链式继承（Son → Dad → Granddad） |
 | **Object 根类** | ⭐⭐⭐⭐ | Java 所有类都隐式继承 Object |
@@ -700,11 +908,14 @@ public class BookManagerTest {
 2. **多层继承 ≠ 多继承**：Java 支持 Son → Dad → Granddad 这样的链式继承，但不支持同时继承多个类
 3. **私有成员不可访问**：子类不能直接使用父类 `private` 修饰的成员
 4. **构造方法不可继承**：父类的构造方法不会被子类继承，子类通过 `super(参数)` 调用父类构造方法
-5. **方法重写 vs 方法重载**：
+5. **子类构造方法默认调用 `super()`**：每个子类构造方法的第一句默认都是 `super()`，如果父类没有无参构造，必须手动 `super(参数)`
+6. **方法重写 vs 方法重载**：
    - 重写（Override）：父子类之间，方法签名完全一致
    - 重载（Overload）：同一个类中，方法名相同参数列表不同
-6. **`@Override` 注解**：不强制但建议加上，可以帮助编译器检查是否真正重写了父类方法
-7. **继承的耦合性**：合理设计继承层次，避免过深的继承链，优先考虑组合而非继承
+7. **`@Override` 注解**：不强制但建议加上，可以帮助编译器检查是否真正重写了父类方法
+8. **变量访问就近原则**：局部 → 本类成员 → 父类成员 → 祖父类成员 → …… → Object
+9. **`super()` 和 `this()` 不能同时出现**：都必须写在构造方法的第一行
+10. **继承的耦合性**：合理设计继承层次，避免过深的继承链，优先考虑组合而非继承
 
 ### 拓展阅读