feat: 新增20260723课堂笔记及授课代码分析——抽象类（abstract）定义与使用（Animal→Cat/Dog、Emp→javaEmp、BaseService→UserService）

README.md

@@ -30,6 +30,7 @@
 | 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）、变量的就近原则查找、this vs super 完整对比、继承中构造方法特点（子类默认调用 super()、父类无无参构造时的处理）、单继承与多层继承、Object 根类、访问修饰符在继承中的体现、随堂练习（学生成绩管理系统-构造方法版）、课后作业（猜数游戏面向对象版/BookManager图书管理系统）](./课堂笔记/01-JavaSE基础-笔记/20260722-笔记.md) |
+| 2026-07-23 | [抽象类：抽象类引出与概念、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可以有构造方法/子类必须重写所有抽象方法或自身也是抽象类）、抽象类代码示例（Animal→Cat/Dog 动物体系、Emp→javaEmp 员工体系、BaseService→UserService 服务层体系）](./课堂笔记/01-JavaSE基础-笔记/20260723-笔记.md) |
 
 ## 二、授课代码
 
@@ -46,6 +47,7 @@
 | 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 关键字、同名属性处理、变量的就近原则查找、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/) |
+| 2026-07-23 | 抽象类（abstract）：抽象类概念与引出、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可有构造方法/子类必须重写所有抽象方法或自身抽象）、抽象类代码示例（Animal→Cat/Dog 动物体系、Emp→javaEmp 员工体系、BaseService→UserService 服务层体系）、Test01 测试类验证多态行为 | `c260723` | [`course`](./授课代码/c260723/src/course/) |
 
 ## 三、课堂练习题
 

授课代码/c260723/.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

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

@@ -0,0 +1,22 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Animal
+ * @description
+ * @create 2026/7/23
+ */
+public abstract class Animal {
+    public Animal(){
+        System.out.println("调用动物的构造方法....");
+    }
+    public abstract void eat();
+
+    public abstract void sleep();
+
+    public abstract void move();
+
+    public abstract void play();
+}

授课代码/c260723/src/course/BaseService.java

@@ -0,0 +1,23 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title BaseService
+ * @description
+ * @create 2026/7/23
+ */
+public abstract class BaseService {
+
+    public abstract void add();
+
+    public abstract void remove();
+
+    public abstract void update();
+
+    public abstract void query();
+
+
+
+}

授课代码/c260723/src/course/Cat.java

@@ -0,0 +1,31 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Cat
+ * @description
+ * @create 2026/7/23
+ */
+public class Cat extends Animal{
+    @Override
+    public void eat() {
+        System.out.println("猫吃鱼");
+    }
+
+    @Override
+    public void sleep() {
+
+    }
+
+    @Override
+    public void move() {
+
+    }
+
+    @Override
+    public void play() {
+
+    }
+}

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

@@ -0,0 +1,59 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 抽象类
+ * @create 2026/7/23
+ */
+public class Demo01 {
+    /*
+        我们在父子类继承的时候，在做子类共性功能抽取的时候，有些方法在父类中并没有具体的实现
+
+        员工类
+            |-开发工程师
+                |-Java开发工程师
+                |-前端开发工程师
+            测试工程师
+                |-后端测试工程师
+                |-IOS测试工程师
+
+         public class 员工{
+            public void work(){
+
+            }
+         }
+         每一个子类的工作内容都是不一样的，所以都需要重写父类的方法。
+         所以， 员工类的work()方法里面的代码就没有作用了。
+
+        在Java中，一个没有方法体的方法 ，应该定义为抽象方法，
+        如果类中包含抽象方法，那么这个类必须是抽象类。
+        Java定义抽象的 关键字 abstract
+
+        抽象类的特点
+            抽象类和抽象方法必须要使用abstract关键字修饰
+
+            定义抽象类：
+            public abstract class 类名{
+
+            }
+            定义抽象方法：
+            public abstract 返回值类型 方法名(参数){
+            }
+
+            抽象类中不一定要有抽象方法，但是有抽象方法的类必须是抽象类
+            【抽象类不能实例化（创建对象）】
+
+            但是 抽象类可以有构造方法
+
+            抽象类的子类，有两种选择：
+                要么重写父类的所有的抽象方法。
+                要么子类也是抽象类，直接继承父类的抽象方法。
+
+            抽象父类 和具体的子类 之间 是继承关系
+            子类还是属于父类类型的。
+
+     */
+}

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

@@ -0,0 +1,30 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description
+ * @create 2026/7/23
+ */
+public class Dog extends Animal{
+    public void eat() {
+        System.out.println("狗吃肉");
+    }
+
+    @Override
+    public void sleep() {
+
+    }
+
+    @Override
+    public void move() {
+
+    }
+
+    @Override
+    public void play() {
+
+    }
+}

授课代码/c260723/src/course/Emp.java

@@ -0,0 +1,18 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Emp
+ * @description
+ * @create 2026/7/23
+ */
+//如果类中有抽象方法（使用abstract修饰的方法），
+// 那么所在的类必须是抽象类（也要使用abstract修饰）
+public abstract class Emp {
+    /**
+     * 抽象方法
+     */
+    public abstract void work();
+}

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

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

授课代码/c260723/src/course/UserService.java

@@ -0,0 +1,32 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title UserService
+ * @description
+ * @create 2026/7/23
+ */
+public class UserService extends BaseService{
+
+    @Override
+    public void add() {
+
+    }
+
+    @Override
+    public void remove() {
+
+    }
+
+    @Override
+    public void update() {
+
+    }
+
+    @Override
+    public void query() {
+
+    }
+}

授课代码/c260723/src/course/javaEmp.java

@@ -0,0 +1,16 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title javaEmp
+ * @description
+ * @create 2026/7/23
+ */
+public class javaEmp extends Emp{
+    @Override
+    public void work() {
+        System.out.println("Java开发工程师在开发Java项目");
+    }
+}

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

@@ -0,0 +1,303 @@
+# JavaSE 基础 — Day09 笔记
+
+> **日期**：2026-07-23  
+> **项目**：`c260723`  
+> **作者**：WanJL
+
+---
+
+## 一、抽象类（Abstract Class）
+
+### 1. 抽象类的引出
+
+**文件**：`Demo01.java`
+
+在父子类继承时，提取子类的共性功能时，有些方法在父类中并没有具体的实现。
+
+例如员工体系：
+
+```
+员工类
+  |- 开发工程师
+     |- Java开发工程师
+     |- 前端开发工程师
+  |- 测试工程师
+     |- 后端测试工程师
+     |- IOS测试工程师
+```
+
+每一个子类的工作内容都是不一样的，所以都需要重写父类的 `work()` 方法，导致父类的 `work()` 方法代码没有实际作用。
+
+```java
+public class 员工 {
+    public void work() {
+        // 每一个子类的工作内容都不一样，此方法体没有意义
+    }
+}
+```
+
+在 Java 中，一个没有方法体的方法，应该定义为 **抽象方法**；如果类中包含抽象方法，那么这个类必须是 **抽象类**。
+
+### 2. 抽象类的定义
+
+**文件**：`Demo01.java`
+
+使用 `abstract` 关键字来定义抽象类和抽象方法。
+
+**定义抽象类**：
+```java
+public abstract class 类名 {
+    // 成员
+}
+```
+
+**定义抽象方法**：
+```java
+public abstract 返回值类型 方法名(参数列表);
+```
+
+> **注意**：抽象方法没有方法体（没有 `{}`，直接以分号结尾）。
+
+### 3. 抽象类的特点
+
+**文件**：`Demo01.java`
+
+| 特性 | 说明 |
+|------|------|
+| **关键字** | 抽象类和抽象方法必须使用 `abstract` 关键字修饰 |
+| **抽象方法所在类** | 有抽象方法的类必须是抽象类 |
+| **抽象类中的抽象方法** | 抽象类中不一定要有抽象方法，但抽象方法必须在抽象类中 |
+| **实例化** | **抽象类不能实例化（不能创建对象）** |
+| **构造方法** | 抽象类可以有构造方法（供子类通过 `super()` 调用） |
+| **子类选择** | ① 重写父类所有的抽象方法；② 子类也是抽象类，直接继承父类的抽象方法 |
+| **继承关系** | 抽象父类和具体子类之间是继承关系，子类仍然属于父类类型 |
+
+---
+
+## 二、抽象类代码示例
+
+### 示例 1：动物体系（Animal → Cat / Dog）
+
+#### 抽象父类 Animal
+
+**文件**：`Animal.java`
+
+```java
+package course;
+
+public abstract class Animal {
+    public Animal() {
+        System.out.println("调用动物的构造方法....");
+    }
+
+    public abstract void eat();
+    public abstract void sleep();
+    public abstract void move();
+    public abstract void play();
+}
+```
+
+- 定义了 4 个抽象方法：`eat()`、`sleep()`、`move()`、`play()`
+- 包含一个构造方法，虽然抽象类不能直接创建对象，但构造方法可以通过子类 `super()` 调用
+
+#### 子类 Cat
+
+**文件**：`Cat.java`
+
+```java
+package course;
+
+public class Cat extends Animal {
+    @Override
+    public void eat() {
+        System.out.println("猫吃鱼");
+    }
+
+    @Override
+    public void sleep() {
+        // 空实现
+    }
+
+    @Override
+    public void move() {
+        // 空实现
+    }
+
+    @Override
+    public void play() {
+        // 空实现
+    }
+}
+```
+
+- 使用 `extends` 继承抽象类 `Animal`
+- 使用 `@Override` 注解重写父类的所有抽象方法（必须全部重写，否则子类也要声明为抽象类）
+
+#### 子类 Dog
+
+**文件**：`Dog.java`
+
+```java
+package course;
+
+public class Dog extends Animal {
+    public void eat() {
+        System.out.println("狗吃肉");
+    }
+
+    @Override
+    public void sleep() { }
+
+    @Override
+    public void move() { }
+
+    @Override
+    public void play() { }
+}
+```
+
+- 同样继承 `Animal`，重写所有抽象方法
+- `eat()` 方法没有写 `@Override` 注解，但仍然是对父类抽象方法的重写（注解只是编译检查，不写也能重写）
+
+#### 测试类 Test01
+
+**文件**：`Test01.java`
+
+```java
+package course;
+
+public class Test01 {
+    public static void main(String[] args) {
+        Dog dog = new Dog();
+        dog.eat();  // 输出：狗吃肉
+    }
+}
+```
+
+- 创建 `Dog` 对象，调用重写后的 `eat()` 方法
+- 验证了抽象类的子类可以正常创建对象和使用成员方法
+
+---
+
+### 示例 2：员工体系（Emp → javaEmp）
+
+#### 抽象父类 Emp
+
+**文件**：`Emp.java`
+
+```java
+package course;
+
+// 有抽象方法的类必须是抽象类
+public abstract class Emp {
+    /**
+     * 抽象方法——没有方法体
+     */
+    public abstract void work();
+}
+```
+
+- 只定义了一个抽象方法 `work()`
+- 类必须使用 `abstract` 修饰
+
+#### 子类 javaEmp
+
+**文件**：`javaEmp.java`
+
+```java
+package course;
+
+public class javaEmp extends Emp {
+    @Override
+    public void work() {
+        System.out.println("Java开发工程师在开发Java项目");
+    }
+}
+```
+
+- 重写父类的 `work()` 抽象方法，给出具体的实现
+- 不同子类可以提供不同的实现（例如还可以有 `前端开发工程师`、`后端测试工程师` 等）
+
+---
+
+### 示例 3：服务层体系（BaseService → UserService）
+
+#### 抽象父类 BaseService
+
+**文件**：`BaseService.java`
+
+```java
+package course;
+
+public abstract class BaseService {
+    public abstract void add();
+    public abstract void remove();
+    public abstract void update();
+    public abstract void query();
+}
+```
+
+- 定义了标准的 CRUD（增删改查）四个抽象方法
+- 在实际项目中常用来定义业务层接口规范
+
+#### 子类 UserService
+
+**文件**：`UserService.java`
+
+```java
+package course;
+
+public class UserService extends BaseService {
+    @Override
+    public void add() { }
+
+    @Override
+    public void remove() { }
+
+    @Override
+    public void update() { }
+
+    @Override
+    public void query() { }
+}
+```
+
+- 重写父类的所有抽象方法
+- 方法体暂时为空，后续可添加具体的业务逻辑
+
+---
+
+## 三、随堂练习要点
+
+**练习目标**：理解抽象类的定义和使用
+
+1. **定义抽象父类**：使用 `public abstract class` 声明，定义抽象方法时不要写方法体
+2. **实现具体子类**：使用 `extends` 继承抽象类，使用 `@Override` 重写所有抽象方法
+3. **测试类验证**：创建子类对象，调用重写后的方法验证正确性
+
+---
+
+## 四、面试常见问题
+
+**Q1：抽象类能不能被实例化？**
+> 不能。抽象类不能直接 `new` 创建对象。
+
+**Q2：抽象类中一定要有抽象方法吗？**
+> 不一定。抽象类中可以没有抽象方法，但有抽象方法的类必须是抽象类。
+
+**Q3：抽象类的子类必须重写所有抽象方法吗？**
+> 不一定。子类有两个选择：① 重写父类所有抽象方法变为具体子类；② 子类也声明为抽象类，继承父类的抽象方法。
+
+**Q4：抽象类可以有构造方法吗？**
+> 可以。虽然抽象类不能直接创建对象，但其构造方法可以在子类实例化时通过 `super()` 调用，用于初始化父类成员。
+
+**Q5：`abstract` 和 `final` 能否同时修饰一个类或方法？**
+> 不能。`abstract` 表示需要被继承/重写，`final` 表示不能被继承/重写，二者语义冲突。
+
+---
+
+## 五、拓展阅读
+
+- [Java 抽象类（Oracle 官方文档）](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+- 抽象类 vs 接口（Interface）的区别（将在后续课程中讲解）
+- 模板方法设计模式（Template Method Pattern）—— 抽象类的经典应用场景