feat: 新增20260722课堂笔记及授课代码分析——继承（extends）概念与使用、学生成绩管理系统、猜数游戏/BookManager课后作业

README.md

@@ -29,6 +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 使用场景、多层继承、随堂练习（学生成绩管理系统-构造方法版）、课后作业（猜数游戏面向对象版/BookManager图书管理系统）](./课堂笔记/01-JavaSE基础-笔记/20260722-笔记.md) |
 
 ## 二、授课代码
 
@@ -44,6 +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 使用场景、多层继承（Animal → Bird → Penguin）、随堂练习（学生成绩管理系统-构造方法版/对象数组/冒泡排序）、课后作业（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/.gitignore

@@ -0,0 +1,30 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

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

@@ -0,0 +1,19 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Animal
+ * @description 动物类
+ * @create 2026/7/22
+ */
+public class Animal {
+
+    public void eat(){
+        System.out.println("吃......");
+    }
+    public void sleep(){
+        System.out.println("睡......");
+    }
+}

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

@@ -0,0 +1,15 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Bird
+ * @description
+ * @create 2026/7/22
+ */
+public class Bird extends Animal{
+    public void fly(){
+        System.out.println("飞.......");
+    }
+}

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

@@ -0,0 +1,82 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description Java继承
+ * @create 2026/7/22
+ */
+public class Demo01 {
+    /*
+        继承：Java的三大特征之一（封装、继承、多态）
+        可以让【子类】具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
+        继承的关键字 extends 直译 是扩展
+        子类具有父类的特征。同时父类其实也是根据多个具有相同特征的子类所抽取出来的。
+
+        动物 类
+         |- 哺乳动物 类
+            |- 猫科动物 类
+                |- 猫 类
+                |- 狮子 类
+                |- 老虎 类
+            |- 犬科动物 类
+                |- 狼 类
+                |- 狗 类
+         |- 爬行动物 类
+         |- 两栖动物 类
+
+
+        员工类 -- 员工编号、员工姓名、员工薪资。打卡的方法()，工作的方法()
+            |- 开发工程师 类
+                |- 前端开发工程师 类
+                |- 后端开发工程师类
+                    |- Java开发工程师 类
+                    |- C++开发工程师 类
+            |- 测试工程师 类
+            |- 运维工程师 类
+            |- 实施工程师 类
+            |- UI设计师 类
+
+        实现继承的格式：
+            class 子类 extends 父类{}
+        比如：
+            class Animal{
+            }
+            class Bird extends Animal{
+
+            }
+            class Penguin extends Bird{
+
+            }
+
+        继承能够带来的好处：
+            继承可以让类和类之间产生关系，父子类关系，产生了父子类关系后，子类可以使用父类中非私有化成员。
+            提高了代码的复用性，多个类的相同成员可以放在同一个父类中。
+            提高了代码的可维护性，如果方法的代码需要改，只需要改父类一处，所有的子类也会继承过去。
+        继承的弊端：
+            继承让类和类之间产生了关系，导致类和类之间的【耦合性】增强了，
+            当父类发生了变化的时候，子类也不得不跟着变化，这就削弱了子类的独立性。
+            子类 继承 了父类，也就必须要依赖父类的存在，如果父类不存在，子类就报错
+            这就是 耦合关系。
+            我们很多的时候都是在研究如何解耦。
+
+        继承使用场景：
+            使用继承要考虑 类和类之间 是否存在 is...a 的关系：
+                谁 是 谁的一种
+                老师是人的一种
+                学生是人的一种
+                人是动物的一种
+                动物是生物的一种
+            Person
+            Student
+            学生是人的一种，那么 人类是父类 学生类是子类，可以建立继承关系
+            Car
+            Student  汽车 跟 学生 不产生is...a关系 所以不能建立继承关系
+     */
+
+
+
+
+}

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

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

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

@@ -0,0 +1,26 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Test01
+ * @description
+ * @create 2026/7/22
+ */
+public class Test01 {
+    public static void main(String[] args) {
+        Animal animal=new Animal();
+        animal.eat();
+        animal.sleep();
+
+
+        Bird bird=new Bird();
+        bird.eat();
+        bird.sleep();
+        bird.fly();
+        Penguin p=new Penguin();
+        p.eat();
+        p.sleep();
+    }
+}

授课代码/c260722/src/exercise/studentSystem/Student.java

@@ -0,0 +1,63 @@
+package exercise.studentSystem;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description
+ * @create 2026/7/22
+ */
+public class Student {
+    private int id;
+    private String name;
+    private double javaScore;
+    private double mysqlScore;
+
+    public Student(int id, String name, double javaScore, double mysqlScore) {
+        this.id = id;
+        this.name = name;
+        this.javaScore = javaScore;
+        this.mysqlScore = mysqlScore;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getJavaScore() {
+        return javaScore;
+    }
+
+    public void setJavaScore(double javaScore) {
+        this.javaScore = javaScore;
+    }
+
+    public double getMysqlScore() {
+        return mysqlScore;
+    }
+
+    public void setMysqlScore(double mysqlScore) {
+        this.mysqlScore = mysqlScore;
+    }
+
+    /**
+     * 计算平均分的方法
+     * @return
+     */
+    public double getAverage(){
+        return (this.javaScore+this.mysqlScore)/2;
+    }
+}

授课代码/c260722/src/exercise/studentSystem/StudentSystem.java

@@ -0,0 +1,83 @@
+package exercise.studentSystem;
+
+
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title StudentSystem
+ * @description
+ * @create 2026/7/22
+ */
+public class StudentSystem {
+    private Student[] students;
+    private int count;
+
+    /**
+     * 这是一个有参的构造方法，当通过这个构造方法创建对象的时候，就可以创建一个指定长度的学生数组
+     * @param capacity 学生数组的容量长度
+     */
+    public StudentSystem(int capacity) {
+        //初始化指定容量的学生数组
+        students=new Student[capacity];
+        count=0;
+    }
+
+    /**
+     * 将学生添加到数组中（如果数组已满，提示"数组已满，添加失败"）
+     * @param s
+     */
+    public void addStudent(Student s){
+        if (count>=this.students.length){
+            System.out.println("数组已满，添加失败");
+        }else {
+            // 向数组中添加一个学生对象
+            students[count]=s;
+            //学生人数+1
+            count++;
+        }
+    }
+
+    /**
+     * 输出所有学生信息（含平均分）
+     */
+    public void printAll(){
+        for (Student s: students){
+            System.out.println("学号："+s.getId()+"，姓名："+s.getName()+
+                    "，Java成绩："+s.getJavaScore()+"，MySQL成绩："+s.getMysqlScore()+
+                    "，平均成绩："+s.getAverage());
+        }
+    }
+
+    /**
+     * 按平均分降序排序（冒泡排序）
+     */
+    public void sortByAverage(){
+        for (int i = 0; i < students.length-1; i++) {
+            for (int j = 0; j < students.length-1-i; j++) {
+                if (students[j].getAverage()<students[j+1].getAverage()){
+                    Student tempStudent=students[j];
+                    students[j]=students[j+1];
+                    students[j+1]=tempStudent;
+                }
+
+            }
+
+        }
+    }
+
+    /**
+     * 返回平均分最高的学生对象
+     * @return
+     */
+    public Student getTopStudent(){
+        Student s=students[0];
+        for (int i = 1; i < students.length; i++) {
+            if (s.getAverage()<students[i].getAverage()){
+                s=students[i];
+            }
+        }
+        return s;
+    }
+}

授课代码/c260722/src/exercise/studentSystem/题目.md

@@ -0,0 +1,29 @@
+## 第 10 题：综合大挑战——学生成绩管理系统（构造方法版）⭐⭐⭐⭐⭐
+
+使用构造方法完成完整的学生成绩管理系统，在包 `system` 下创建以下类：
+
+**`StudentV5` 类**（实体类）：
+
+- **私有属性**：`id`（学号，int）、`name`（姓名，String）、`javaScore`（Java 成绩，double）、`mysqlScore`（MySQL 成绩，double）
+- **全参构造方法**
+- **getter/setter**
+- **方法**：`getAverage()` 返回两门课的平均分
+
+**`StudentSystem` 类**（业务类）：
+
+- **私有属性**：`StudentV5[] students`（学生数组）、`count`（当前学生数量）
+- **构造方法**：`StudentSystem(int capacity)` —— 初始化指定容量的学生数组
+- **方法**：
+    - `addStudent(StudentV5 s)` —— 将学生添加到数组中（如果数组已满，提示"数组已满，添加失败"）
+    - `printAll()` —— 输出所有学生信息（含平均分）
+    - `sortByAverage()` —— 按平均分降序排序（冒泡排序）
+    - `getTopStudent()` —— 返回平均分最高的学生对象
+
+**`SystemTest` 类**（测试类）：
+
+1. 创建 `StudentSystem` 对象，容量为 5
+2. 使用全参构造创建 5 个学生对象
+3. 调用 `addStudent()` 逐个添加学生
+4. 调用 `printAll()` 输出所有学生信息
+5. 调用 `sortByAverage()` 排序后再次输出
+6. 调用 `getTopStudent()` 输出最高分学生信息

授课代码/c260722/src/homework/p08_guessgame/GuessGame.java

@@ -0,0 +1,81 @@
+package homework.p08_guessgame;
+
+
+import java.util.Random;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title GuessGame
+ * @description
+ *
+ *
+ * @create 2026/7/22
+ */
+public class GuessGame {
+    /**
+     * 目标数字（系统随机生成）
+     */
+    private int target;
+    /**
+     * 最大范围（如 100 表示 1~100）
+     */
+    private int maxRange;
+    /**
+     * 已猜次数
+     */
+    private int attempts;
+
+    public GuessGame(int maxRange) {
+        Random random=new Random();
+        this.maxRange = maxRange;
+        //并将 attempts 初始化为 0
+        this.attempts=0;
+        target=random.nextInt(this.maxRange)+1;
+    }
+
+    /**
+     * 猜数字的方法
+     * @param num
+     * @return
+     */
+    public String guess(int num){
+        //已猜次数加1
+        this.attempts++;
+        if (num>target){
+            return "猜大了";
+        }else if(num<this.target){
+            return "猜小了";
+        }else{
+            return "猜对了";
+        }
+    }
+
+    /**
+     * 返回已猜次数
+     * @return
+     */
+    public int getAttempts(){
+        return this.attempts;
+    }
+
+    public int getTarget() {
+        return target;
+    }
+
+    public void setTarget(int target) {
+        this.target = target;
+    }
+
+    public int getMaxRange() {
+        return maxRange;
+    }
+
+    public void setMaxRange(int maxRange) {
+        this.maxRange = maxRange;
+    }
+
+    public void setAttempts(int attempts) {
+        this.attempts = attempts;
+    }
+}

授课代码/c260722/src/homework/p08_guessgame/GuessGameTest.java

@@ -0,0 +1,28 @@
+package homework.p08_guessgame;
+
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title GuessGameTest
+ * @description
+ * @create 2026/7/22
+ */
+public class GuessGameTest {
+    public static void main(String[] args) {
+        GuessGame gg=new GuessGame(100);
+        Scanner sc=new Scanner(System.in);
+        while (true){
+            System.out.print("请输入你猜的数字:");
+            int num = sc.nextInt();
+            String guess = gg.guess(num);
+            System.out.println(guess);
+            if (guess=="猜对了"){
+                break;
+            }
+        }
+        System.out.println("恭喜你！一共猜了 "+gg.getAttempts()+" 次");
+    }
+}

授课代码/c260722/src/homework/p08_guessgame/题目.md

@@ -0,0 +1,52 @@
+## 第 8 题：构造方法 + Random + 方法——猜数游戏（面向对象版）⭐⭐⭐⭐
+
+**包名**：`p08_guessgame`
+
+将之前的猜数字游戏改造为**面向对象版本**，使用构造方法初始化游戏。
+
+### 游戏类（类名自拟，置于 `p08_guessgame` 包下）
+
+**私有属性**：
+
+| 属性       | 类型 | 说明                          |
+| ---------- | ---- | ----------------------------- |
+| `target`   | int  | 目标数字（系统随机生成）      |
+| `maxRange` | int  | 最大范围（如 100 表示 1~100） |
+| `attempts` | int  | 已猜次数                      |
+
+**构造方法**：`类名(int maxRange)` —— 在 `1 ~ maxRange` 之间用 Random 生成目标数字，并将 `attempts` 初始化为 0
+
+**方法**：
+
+| 方法             | 说明                                                         |
+| ---------------- | ------------------------------------------------------------ |
+| `guess(int num)` | 判断猜测结果，返回 `String`：`"猜对了！"` / `"大了，再小点"` / `"小了，再大点"` |
+| `getAttempts()`  | 返回已猜次数（int）                                          |
+
+### 测试类要求（测试类类名自拟，置于 `p08_guessgame` 包下）
+
+1. 创建游戏对象，范围 1~100
+2. 使用 `Scanner` 让用户循环输入猜测数字
+3. 调用 `guess()` 方法判断，直到猜对为止
+4. 猜对后输出总共猜了多少次
+
+**示例运行效果**：
+
+```
+======= 猜数游戏（1~100） =======
+请输入你猜的数字：50
+小了，再大点
+请输入你猜的数字：75
+大了，再小点
+请输入你猜的数字：62
+小了，再大点
+请输入你猜的数字：68
+猜对了！
+恭喜你！一共猜了 4 次
+```
+
+> 💡 **提示**：
+>
+> - 构造方法中使用 `Random` 的 `nextInt(maxRange) + 1` 生成 1~maxRange 的随机数
+> - `guess()` 方法中每次调用时 `attempts` 自增 1
+> - 测试类中使用 `while(true)` 循环，猜对时 `break`

授课代码/c260722/src/homework/p09_bookmanager/Book.java

@@ -0,0 +1,45 @@
+package homework.p09_bookmanager;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Book
+ * @description 图书类
+ * @create 2026/7/22
+ */
+public class Book {
+    private int id;
+    private String title;
+    private double price;
+
+    public Book(int id, String title, double price) {
+        this.id = id;
+        this.title = title;
+        this.price = price;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+}

授课代码/c260722/src/homework/p09_bookmanager/BookManager.java

@@ -0,0 +1,73 @@
+package homework.p09_bookmanager;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title BookManager
+ * @description 管理类
+ * @create 2026/7/22
+ */
+public class BookManager {
+    /**
+     * 创建并返回一个包含 5 本图书 的数组（使用全参构造初始化）
+     * @return
+     */
+    public Book[] initBooks(){
+        //创建5个图书对象
+        Book b1=new Book(1001,"Java从入门到精通",79.0);
+        Book b2=new Book(1002,"数据结构与算法",65.0);
+        Book b3=new Book(1003,"设计模式之禅",58.0);
+        Book b4=new Book(1004,"深入理解JVM",89.0);
+        Book b5=new Book(1005,"计算机网络",45.0);
+        //创建一个长度为5的图书数组---静态初始化
+        Book[] books={b1,b2,b3,b4,b5};
+        //返回数组
+        return books;
+    }
+
+    /**
+     * 遍历输出所有图书信息
+     * @param books
+     */
+    public void printBooks(Book[] books){
+        for(Book b:books){
+            System.out.println("编号："+b.getId()+"，书名："+b.getTitle()+"，价格："+b.getPrice());
+        }
+    }
+
+    /**
+     * 按价格从高到低排序（冒泡排序）
+     * @param books
+     */
+    public void sortByPrice(Book[] books){
+        //外层循环
+        for (int i = 0; i < books.length-1; i++) {
+            //内层循环
+            for (int j = 0; j < books.length-1-i; j++) {
+                //注意：不是直接笔记book对象，而是笔记book的价格属性
+                if (books[j].getPrice()<books[j+1].getPrice()){
+                    Book tempBook=books[j];
+                    books[j]=books[j+1];
+                    books[j+1]=tempBook;
+                }
+            }
+        }
+    }
+
+    /**
+     * 根据书名查找图书，返回找到的图书对象（找不到返回 null）
+     * @param books
+     * @param title
+     * @return
+     */
+    public Book searchByTitle(Book[] books, String title){
+        for (Book b:books){
+            if (b.getTitle()==title){
+                return b;
+            }
+        }
+        return null;
+    }
+
+}

授课代码/c260722/src/homework/p09_bookmanager/BookManagerTest.java

@@ -0,0 +1,38 @@
+package homework.p09_bookmanager;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title BookManagerTest
+ * @description
+ * @create 2026/7/22
+ */
+public class BookManagerTest {
+    public static void main(String[] args) {
+        BookManager bm=new BookManager();
+        Book[] books = bm.initBooks();
+        System.out.println("========== 原始顺序 ==========");
+        bm.printBooks(books);
+        bm.sortByPrice(books);
+        System.out.println("========== 按价格从高到低排序 ==========");
+        bm.printBooks(books);
+        System.out.println("========== 查找图书 ==========");
+        String bookName="设计模式之禅";
+        System.out.println("查找“"+bookName+"”：");
+        Book book = bm.searchByTitle(books, bookName);
+        if (book==null){
+            System.out.println("未找到该图书！");
+        }else {
+            System.out.println("找到了！编号："+book.getId()+"，价格："+book.getPrice());
+        }
+        String bookName1="操作系统";
+        System.out.println("查找“"+bookName1+"”：");
+        Book book1 = bm.searchByTitle(books, bookName1);
+        if (book1==null){
+            System.out.println("未找到该图书！");
+        }else {
+            System.out.println("找到了！编号："+book1.getId()+"，价格："+book1.getPrice());
+        }
+    }
+}

授课代码/c260722/src/homework/p09_bookmanager/题目.md

@@ -0,0 +1,69 @@
+## 第 9 题：构造方法 + 封装 + 对象数组 + 排序——BookManager ⭐⭐⭐⭐
+
+**包名**：`p09_bookmanager`
+
+### 图书类（类名自拟，置于 `p09_bookmanager` 包下）
+
+- **私有属性**：`id`（编号，int）、`title`（书名，String）、`price`（价格，double）
+- **全参构造方法**
+- **getter/setter**
+
+### 管理类（类名自拟，置于 `p09_bookmanager` 包下）
+
+包含以下方法：
+
+| 方法                                              | 说明                                                         |
+| ------------------------------------------------- | ------------------------------------------------------------ |
+| `initBooks()`                                     | 创建并返回一个包含 **5 本图书** 的数组（使用全参构造初始化） |
+| `printBooks(图书数组类型 books)`                  | 遍历输出所有图书信息                                         |
+| `sortByPrice(图书数组类型 books)`                 | 按价格**从高到低**排序（冒泡排序）                           |
+| `searchByTitle(图书数组类型 books, String title)` | 根据书名查找图书，返回找到的图书对象（找不到返回 `null`）    |
+
+### 测试类要求（测试类类名自拟，置于 `p09_bookmanager` 包下）
+
+1. 调用 `initBooks()` 初始化图书数组
+2. 调用 `printBooks()` 输出原始顺序
+3. 调用 `sortByPrice()` 排序后再次输出
+4. 调用 `searchByTitle()` 查找某本书，输出查找结果
+
+**示例数据**：
+
+```java
+new 图书类(1001, "Java从入门到精通", 79.0)
+new 图书类(1002, "数据结构与算法", 65.0)
+new 图书类(1003, "设计模式之禅", 58.0)
+new 图书类(1004, "深入理解JVM", 89.0)
+new 图书类(1005, "计算机网络", 45.0)
+```
+
+**示例运行效果**：
+
+```
+========== 原始顺序 ==========
+编号：1001，书名：Java从入门到精通，价格：79.0
+编号：1002，书名：数据结构与算法，价格：65.0
+编号：1003，书名：设计模式之禅，价格：58.0
+编号：1004，书名：深入理解JVM，价格：89.0
+编号：1005，书名：计算机网络，价格：45.0
+
+========== 按价格从高到低排序 ==========
+编号：1004，书名：深入理解JVM，价格：89.0
+编号：1001，书名：Java从入门到精通，价格：79.0
+编号：1002，书名：数据结构与算法，价格：65.0
+编号：1003，书名：设计模式之禅，价格：58.0
+编号：1005，书名：计算机网络，价格：45.0
+
+========== 查找图书 ==========
+查找 "设计模式之禅"：
+  找到了！编号：1003，价格：58.0
+
+查找 "操作系统"：
+  未找到该图书！
+```
+
+> 💡 **提示**：
+>
+> - `initBooks()` 是**无参有返回值**方法，在方法内部创建数组并返回
+> - 冒泡排序中比较价格时，使用 `>` 进行降序排列（从高到低）
+> - `searchByTitle()` 使用 `equals()` 或 `equalsIgnoreCase()` 比较书名
+> - 管理类的方法都是**实例方法**，测试类中需先创建管理类对象再调用

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

@@ -0,0 +1,467 @@
+# JavaSE 基础 — Day08 笔记
+
+> **日期**：2026-07-22  
+> **项目**：`c260722`  
+> **作者**：WanJL
+
+---
+
+## 一、继承（Inheritance）
+
+### 1. 继承的概念
+
+**文件**：`Demo01.java`
+
+继承是 Java 三大特征之一（封装、继承、多态）。继承可以让**子类**具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。
+
+继承的关键字是 `extends`，直译是「扩展」，含义是子类在父类的基础上进行扩展。
+
+**核心思想**：
+- 子类具有父类的特征
+- 父类是根据多个具有相同特征的子类所抽取出来的公共部分
+
+**类的层次结构示例**：
+```
+动物 类
+  |- 哺乳动物 类
+     |- 猫科动物 类
+        |- 猫 类
+        |- 狮子 类
+        |- 老虎 类
+     |- 犬科动物 类
+        |- 狼 类
+        |- 狗 类
+  |- 爬行动物 类
+  |- 两栖动物 类
+```
+
+### 2. 继承的格式
+
+**文件**：`Demo01.java`
+
+```java
+class 子类 extends 父类 {
+    // 子类自己的成员
+}
+```
+
+**示例**：
+```java
+class Animal {                  // 父类
+}
+
+class Bird extends Animal {     // 子类 Bird 继承 Animal
+}
+
+class Penguin extends Bird {    // 子类 Penguin 继承 Bird（多层继承）
+}
+```
+
+### 3. 继承体系示例
+
+**文件**：`Animal.java`、`Bird.java`、`Penguin.java`
+
+```java
+// 父类 Animal —— 定义所有动物共有的行为
+public class Animal {
+    public void eat() {
+        System.out.println("吃......");
+    }
+    public void sleep() {
+        System.out.println("睡......");
+    }
+}
+
+// 子类 Bird —— 继承 Animal，追加 fly 方法
+public class Bird extends Animal {
+    public void fly() {
+        System.out.println("飞.......");
+    }
+}
+
+// 子类 Penguin —— 继承 Bird（多层继承）
+public class Penguin extends Bird {
+    // 继承了 Animal 的 eat()、sleep() 和 Bird 的 fly()
+}
+```
+
+### 4. 继承的使用
+
+**文件**：`Test01.java`
+
+```java
+public class Test01 {
+    public static void main(String[] args) {
+        // 父类对象只能使用自己的方法
+        Animal animal = new Animal();
+        animal.eat();
+        animal.sleep();
+
+        // Bird 对象可以使用父类 Animal 的方法 + 自己的方法
+        Bird bird = new Bird();
+        bird.eat();     // 继承自 Animal
+        bird.sleep();   // 继承自 Animal
+        bird.fly();     // 自己的方法
+
+        // Penguin 对象可以使用所有继承来的方法
+        Penguin p = new Penguin();
+        p.eat();        // 继承自 Animal → Bird → Penguin
+        p.sleep();      // 继承自 Animal → Bird → Penguin
+    }
+}
+```
+
+### 5. 继承的好处
+
+**文件**：`Demo01.java`
+
+| 好处 | 说明 |
+|------|------|
+| **代码复用性** | 多个类的相同成员可以放在同一个父类中，子类自动拥有 |
+| **代码可维护性** | 父类方法修改一处，所有子类都继承修改后的版本 |
+| **建立类与类的关系** | 产生父子类关系后，子类可使用父类中非私有化成员 |
+
+```java
+// 如果修改 Animal 的 eat() 方法，所有子类都会生效
+public class Animal {
+    public void eat() {
+        System.out.println("正在吃东西......");  // 改这里就行
+    }
+}
+```
+
+### 6. 继承的弊端——耦合性
+
+**文件**：`Demo01.java`
+
+继承让类和类之间产生了关系，导致**耦合性增强**：
+- 父类发生变化时，子类也不得不跟着变化
+- 子类依赖父类的存在，如果父类不存在，子类就报错
+- 这削弱了子类的独立性
+
+> 耦合关系（Coupling）：类与类之间的依赖程度。程序设计很多时候都在研究如何**解耦**。
+
+### 7. 继承的使用场景——is...a 关系
+
+**文件**：`Demo01.java`
+
+使用继承前要考虑类和类之间是否存在 **is...a** 关系（谁是谁的一种）：
+
+| 正确（符合 is...a） | 错误（不符合 is...a） |
+|---------------------|----------------------|
+| 老师**是**人的一种 | 汽车**是**学生的一种 ✗ |
+| 学生**是**人的一种 | |
+| 人**是**动物的一种 | |
+| 动物**是**生物的一种 | |
+
+```java
+// 正确的继承设计
+class Person { }
+class Student extends Person { }   // 学生是人的一种 ✓
+
+// 错误的继承设计
+class Car { }
+class Student extends Car { }      // 学生不是汽车的一种 ✗
+```
+
+---
+
+## 二、随堂练习——学生成绩管理系统（构造方法版）
+
+**包名**：`exercise.studentSystem`
+
+### 题目要求
+
+使用构造方法完成完整的学生成绩管理系统，包含三个类：
+
+### Student 类（实体类）
+
+**文件**：`Student.java`
+
+```java
+public class Student {
+    private int id;           // 学号
+    private String name;      // 姓名
+    private double javaScore; // Java 成绩
+    private double mysqlScore;// MySQL 成绩
+
+    // 全参构造方法
+    public Student(int id, String name, double javaScore, double mysqlScore) {
+        this.id = id;
+        this.name = name;
+        this.javaScore = javaScore;
+        this.mysqlScore = mysqlScore;
+    }
+
+    // getter/setter...
+
+    // 计算平均分的方法
+    public double getAverage() {
+        return (this.javaScore + this.mysqlScore) / 2;
+    }
+}
+```
+
+### StudentSystem 类（业务类）
+
+**文件**：`StudentSystem.java`
+
+```java
+public class StudentSystem {
+    private Student[] students;  // 学生数组
+    private int count;           // 当前学生数量
+
+    // 构造方法：初始化指定容量的学生数组
+    public StudentSystem(int capacity) {
+        students = new Student[capacity];
+        count = 0;
+    }
+
+    // 添加学生到数组中
+    public void addStudent(Student s) {
+        if (count >= this.students.length) {
+            System.out.println("数组已满，添加失败");
+        } else {
+            students[count] = s;
+            count++;
+        }
+    }
+
+    // 输出所有学生信息（含平均分）
+    public void printAll() {
+        for (Student s : students) {
+            System.out.println("学号：" + s.getId() + "，姓名：" + s.getName()
+                + "，Java成绩：" + s.getJavaScore() + "，MySQL成绩：" + s.getMysqlScore()
+                + "，平均成绩：" + s.getAverage());
+        }
+    }
+
+    // 按平均分降序排序（冒泡排序）
+    public void sortByAverage() {
+        for (int i = 0; i < students.length - 1; i++) {
+            for (int j = 0; j < students.length - 1 - i; j++) {
+                if (students[j].getAverage() < students[j + 1].getAverage()) {
+                    Student temp = students[j];
+                    students[j] = students[j + 1];
+                    students[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    // 返回平均分最高的学生对象
+    public Student getTopStudent() {
+        Student s = students[0];
+        for (int i = 1; i < students.length; i++) {
+            if (s.getAverage() < students[i].getAverage()) {
+                s = students[i];
+            }
+        }
+        return s;
+    }
+}
+```
+
+### 涉及知识点
+
+| 知识点 | 说明 |
+|--------|------|
+| 全参构造方法 | 创建对象时直接初始化所有属性 |
+| 对象数组 | 存储多个学生对象 |
+| 增强 for 循环 | 遍历数组输出信息 |
+| 冒泡排序 | 按对象属性（平均分）排序 |
+| 方法调用链 | `students[j].getAverage()` 获取对象属性进行比较 |
+| 数组满判断 | `count >= students.length` 防止越界 |
+
+---
+
+## 三、课后作业
+
+### 作业 1：猜数游戏（面向对象版）⭐️⭐️⭐️⭐️
+
+**包名**：`homework.p08_guessgame`
+
+**文件**：`GuessGame.java`、`GuessGameTest.java`
+
+使用构造方法 + Random + 方法，将猜数字游戏改造为面向对象版本。
+
+**GuessGame 类**：
+```java
+public class GuessGame {
+    private int target;     // 目标数字（随机生成）
+    private int maxRange;   // 最大范围
+    private int attempts;   // 已猜次数
+
+    // 构造方法：生成随机目标数字
+    public GuessGame(int maxRange) {
+        Random random = new Random();
+        this.maxRange = maxRange;
+        this.attempts = 0;
+        target = random.nextInt(this.maxRange) + 1;  // 1~maxRange
+    }
+
+    // 猜数字方法
+    public String guess(int num) {
+        this.attempts++;
+        if (num > target) {
+            return "猜大了";
+        } else if (num < this.target) {
+            return "猜小了";
+        } else {
+            return "猜对了";
+        }
+    }
+
+    public int getAttempts() {
+        return this.attempts;
+    }
+}
+```
+
+**GuessGameTest 测试类**：
+```java
+public class GuessGameTest {
+    public static void main(String[] args) {
+        GuessGame gg = new GuessGame(100);
+        Scanner sc = new Scanner(System.in);
+        while (true) {
+            System.out.print("请输入你猜的数字:");
+            int num = sc.nextInt();
+            String guess = gg.guess(num);
+            System.out.println(guess);
+            if (guess == "猜对了") {  // 注意：字符串比较建议用 equals()
+                break;
+            }
+        }
+        System.out.println("恭喜你！一共猜了 " + gg.getAttempts() + " 次");
+    }
+}
+```
+
+### 作业 2：BookManager 图书管理系统 ⭐️⭐️⭐️⭐️
+
+**包名**：`homework.p09_bookmanager`
+
+**文件**：`Book.java`、`BookManager.java`、`BookManagerTest.java`
+
+综合练习：构造方法 + 封装 + 对象数组 + 排序 + 查找
+
+**Book 类**（实体类）：
+```java
+public class Book {
+    private int id;        // 编号
+    private String title;  // 书名
+    private double price;  // 价格
+
+    // 全参构造方法
+    public Book(int id, String title, double price) {
+        this.id = id;
+        this.title = title;
+        this.price = price;
+    }
+    // getter/setter...
+}
+```
+
+**BookManager 类**（业务类）：
+```java
+public class BookManager {
+    // 初始化 5 本图书
+    public Book[] initBooks() {
+        Book b1 = new Book(1001, "Java从入门到精通", 79.0);
+        Book b2 = new Book(1002, "数据结构与算法", 65.0);
+        Book b3 = new Book(1003, "设计模式之禅", 58.0);
+        Book b4 = new Book(1004, "深入理解JVM", 89.0);
+        Book b5 = new Book(1005, "计算机网络", 45.0);
+        Book[] books = {b1, b2, b3, b4, b5};  // 静态初始化
+        return books;
+    }
+
+    // 遍历所有图书
+    public void printBooks(Book[] books) {
+        for (Book b : books) {
+            System.out.println("编号：" + b.getId() + "，书名：" + b.getTitle()
+                + "，价格：" + b.getPrice());
+        }
+    }
+
+    // 按价格从高到低排序（冒泡排序）
+    public void sortByPrice(Book[] books) {
+        for (int i = 0; i < books.length - 1; i++) {
+            for (int j = 0; j < books.length - 1 - i; j++) {
+                if (books[j].getPrice() < books[j + 1].getPrice()) {
+                    Book temp = books[j];
+                    books[j] = books[j + 1];
+                    books[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    // 根据书名查找图书
+    public Book searchByTitle(Book[] books, String title) {
+        for (Book b : books) {
+            if (b.getTitle() == title) {  // 建议用 equals()
+                return b;
+            }
+        }
+        return null;
+    }
+}
+```
+
+**BookManagerTest 测试类**：
+```java
+public class BookManagerTest {
+    public static void main(String[] args) {
+        BookManager bm = new BookManager();
+        Book[] books = bm.initBooks();
+
+        System.out.println("========== 原始顺序 ==========");
+        bm.printBooks(books);
+
+        bm.sortByPrice(books);
+        System.out.println("========== 按价格从高到低排序 ==========");
+        bm.printBooks(books);
+
+        System.out.println("========== 查找图书 ==========");
+        String bookName = "设计模式之禅";
+        Book book = bm.searchByTitle(books, bookName);
+        if (book == null) {
+            System.out.println("未找到该图书！");
+        } else {
+            System.out.println("找到了！编号：" + book.getId() + "，价格：" + book.getPrice());
+        }
+    }
+}
+```
+
+---
+
+## 四、今日知识点总结
+
+### 核心知识点
+
+| 知识点 | 重要程度 | 说明 |
+|--------|---------|------|
+| **继承的概念** | ⭐⭐⭐⭐⭐ | Java 三大特征之一，子类 extends 父类 |
+| **继承的格式** | ⭐⭐⭐⭐⭐ | `class 子类 extends 父类 {}` |
+| **继承的好处** | ⭐⭐⭐⭐ | 提高代码复用性和可维护性 |
+| **继承的弊端（耦合性）** | ⭐⭐⭐⭐ | 父类变化影响子类，降低独立性 |
+| **is...a 关系判断** | ⭐⭐⭐⭐ | 使用继承前必须判断是否符合 is...a |
+| **多层继承** | ⭐⭐⭐ | 一个类可继承自另一个已继承的子类 |
+| **构造方法 + 对象数组 + 冒泡排序综合应用** | ⭐⭐⭐⭐⭐ | 学生管理系统、图书管理系统 |
+
+### 注意事项
+
+1. **继承是单继承**：Java 中一个类只能有一个直接父类（单继承体系）
+2. **私有成员不可继承**：子类不能使用父类中 `private` 修饰的成员
+3. **构造方法不可继承**：父类的构造方法不会被子类继承，但子类可以通过 `super()` 调用
+4. **继承的耦合性**：合理设计继承层次，避免过深的继承链
+
+### 拓展阅读
+
+- Java 继承中 `super` 关键字的使用
+- 方法重写（Override）与方法重载（Overload）的区别
+- `final` 关键字对继承的限制（`final` 类不能被继承，`final` 方法不能被重写）
+- 继承与组合（Composition）的对比——优先使用组合而非继承