docs: 更新20260723课堂笔记，同步代码变更——新增模板方法设计模式（MyOneDayTemplate/ZhSanOneDay/LiSiOneDay）和常量全大写命名规范

README.md

@@ -30,7 +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）+ final 关键字：抽象类引出与概念、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可有构造方法/子类必须重写所有抽象方法或自身抽象）、抽象类代码示例（Animal→Cat/Dog 动物体系、Emp→javaEmp 员工体系、BaseService→UserService 服务层体系）；final 修饰类（禁止继承）、final 修饰方法（禁止重写）、final 修饰变量（变成常量）、final 引用类型（引用地址不可变但对象内容可修改）、final vs abstract 对比；随堂练习（Shape 抽象类计算周长+面积）](./课堂笔记/01-JavaSE基础-笔记/20260723-笔记.md) |
+| 2026-07-23 | [抽象类（abstract）+ final 关键字 + 模板方法设计模式：抽象类引出与概念、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可有构造方法/子类必须重写所有抽象方法或自身抽象）、抽象类代码示例（Animal→Cat/Dog 动物体系、Emp→javaEmp 员工体系、BaseService→UserService 服务层体系）；final 修饰类（禁止继承）/修饰方法（禁止重写）/修饰变量（变成常量、常量全大写命名规范）、final 引用类型（引用地址不可变但对象内容可修改）、final vs abstract 对比；模板方法设计模式（Template Method Pattern）：模板类组成（final 模板方法 + abstract 定制方法）、MyOneDayTemplate 示例（ZhSanOneDay / LiSiOneDay）、模板方法 vs 普通继承+重写对比；随堂练习（Shape 抽象类计算周长+面积）](./课堂笔记/01-JavaSE基础-笔记/20260723-笔记.md) |
 
 ## 二、授课代码
 
@@ -47,7 +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/) |
+| 2026-07-23 | 抽象类（abstract）：抽象类概念与引出、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可有构造方法/子类必须重写所有抽象方法或自身抽象）、抽象类代码示例（Animal→Cat/Dog 动物体系、Emp→javaEmp 员工体系、BaseService→UserService 服务层体系）、Test01 测试类验证多态行为；final 关键字（final 类/方法/变量/引用类型、常量全大写规范、Test02 测试 final 行为）；模板方法设计模式——MyOneDayTemplate（final 模板方法 myOneDay + 抽象方法 eat/sleep/play，ZhSanOneDay / LiSiOneDay 子类实现，Test03 测试） | `c260723` | [`course`](./授课代码/c260723/src/course/) |
 
 ## 三、课堂练习题
 

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

@@ -17,6 +17,7 @@ public class Demo02 {
         }
         使用final修饰的类，不能被继承.
         使用final修饰的变量，不能被修改，这个变量就变成了常量。只能调用，不能修改。
+        Java中一般常量名称是全大写。
         使用final修饰的方法，不能被子类重写。
 
         修饰类的场景：

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

@@ -0,0 +1,19 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2026/7/23
+ */
+public class Demo03 {
+    /*
+        Java中的设计模式：模板模式
+        是把抽象类整体看成是一个模版，模板中不能 决定的东西，抽象成方法
+        让使用模板的类，（也就是抽象类的子类）去重新抽象方法，实现定制化的需求。
+        模板模式的优势：
+            模板已经定义了通用的结构，使用者只需要关心自己需要实现的功能就可以了
+     */
+}

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

@@ -0,0 +1,26 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title ZhSanOneDay
+ * @description
+ * @create 2026/7/23
+ */
+public class LiSiOneDay extends MyOneDayTemplate{
+    @Override
+    public void eat() {
+        System.out.println("饭");
+    }
+
+    @Override
+    public void sleep() {
+        System.out.println("菜");
+    }
+
+    @Override
+    public void play() {
+        System.out.println("小狗");
+    }
+}

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

@@ -0,0 +1,40 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title MyOneDayTemplate
+ * @description
+ * @create 2026/7/23
+ */
+public abstract class MyOneDayTemplate {
+
+    /*
+        一般 模板类分为两部分：
+           1、 1个是使用final修饰的不能被重写的，只能被调用的 方法
+                方法里面一般是执行步骤。
+           2、 另1个是使用abstract修饰的需要被重写的方法
+
+     */
+
+    /**
+     * 只能使用，不能修改
+     */
+    public final void myOneDay(){
+        System.out.print("《我的一天》");
+        System.out.print("今天我吃了");
+        this.eat();
+        System.out.print("然后我又");
+        this.sleep();
+        System.out.print("最后我又玩了");
+        this.play();
+        System.out.print("好开心哟~");
+        System.out.println();
+    }
+
+    public abstract void eat();
+    public abstract void sleep();
+    public abstract void play();
+
+}

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

@@ -0,0 +1,18 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Test03
+ * @description
+ * @create 2026/7/23
+ */
+public class Test03 {
+    public static void main(String[] args) {
+        ZhSanOneDay zhSanOneDay=new ZhSanOneDay();
+        zhSanOneDay.myOneDay();
+        LiSiOneDay li=new LiSiOneDay();
+        li.myOneDay();
+    }
+}

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

@@ -0,0 +1,26 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title ZhSanOneDay
+ * @description
+ * @create 2026/7/23
+ */
+public class ZhSanOneDay extends MyOneDayTemplate{
+    @Override
+    public void eat() {
+        System.out.println("饭");
+    }
+
+    @Override
+    public void sleep() {
+        System.out.println("菜");
+    }
+
+    @Override
+    public void play() {
+        System.out.println("小狗");
+    }
+}

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

@@ -339,6 +339,14 @@ p.setId("1002");
 System.out.printf(p.showInfo());  // 输出：Person{id='1002', name='李四'}
 ```
 
+**常量命名规范**：Java 中一般使用 `final` 修饰的变量作为常量，常量名称通常 **全部大写**，单词之间用下划线 `_` 分隔。例如：
+
+```java
+final String SPRING = "春天";     // FinalClass.java
+final int MAX_STUDENT_COUNT = 100;
+final double PI = 3.1415926;
+```
+
 **关键区别**：
 
 | 变量类型 | final 的作用 | 示例 |
@@ -445,7 +453,147 @@ public class Test {
 
 ---
 
-## 五、随堂练习要点
+## 五、模板方法设计模式（Template Method Pattern）
+
+### 1. 模板方法的引出
+
+**文件**：`Demo03.java`
+
+**模板方法模式**是抽象类的经典应用场景。核心思想：**父类定义算法的「骨架」（通用结构），子类实现特定的「步骤」（定制化需求）**。
+
+```
+Java中的设计模式：模板模式
+是把抽象类整体看成是一个模版，模板中不能决定的东西，抽象成方法
+让使用模板的类（也就是抽象类的子类）去重写抽象方法，实现定制化的需求。
+模板模式的优势：
+    模板已经定义了通用的结构，使用者只需要关心自己需要实现的功能就可以了
+```
+
+### 2. 模板类的组成
+
+**文件**：`MyOneDayTemplate.java`
+
+一般模板类分为两部分：
+
+| 组成部分 | 关键字 | 说明 |
+|---------|--------|------|
+| **模板方法** | `final` | 定义执行步骤的骨架，子类不能修改（不能重写） |
+| **抽象方法** | `abstract` | 需要被子类重写的方法，具体行为由子类决定 |
+
+```java
+package course;
+
+public abstract class MyOneDayTemplate {
+
+    /**
+     * 模板方法——使用 final 修饰，只能使用，不能修改
+     */
+    public final void myOneDay() {
+        System.out.print("《我的一天》");
+        System.out.print("今天我吃了");
+        this.eat();         // 步骤 1：吃（抽象方法，子类实现）
+        System.out.print("然后我又");
+        this.sleep();       // 步骤 2：睡（抽象方法，子类实现）
+        System.out.print("最后我又玩了");
+        this.play();        // 步骤 3：玩（抽象方法，子类实现）
+        System.out.print("好开心哟~");
+        System.out.println();
+    }
+
+    // 抽象方法——由子类提供具体的实现
+    public abstract void eat();
+    public abstract void sleep();
+    public abstract void play();
+}
+```
+
+> **关键点**：`myOneDay()` 用 `final` 修饰，确保子类不能篡改这个方法的结构。子类只需关注 `eat()`、`sleep()`、`play()` 三个抽象方法的具体实现。
+
+### 3. 子类实现
+
+**文件**：`ZhSanOneDay.java`、`LiSiOneDay.java`
+
+```java
+// 张三的一天
+public class ZhSanOneDay extends MyOneDayTemplate {
+    @Override
+    public void eat() {
+        System.out.println("饭");
+    }
+
+    @Override
+    public void sleep() {
+        System.out.println("菜");
+    }
+
+    @Override
+    public void play() {
+        System.out.println("小狗");
+    }
+}
+
+// 李四的一天
+public class LiSiOneDay extends MyOneDayTemplate {
+    @Override
+    public void eat() {
+        System.out.println("饭");
+    }
+
+    @Override
+    public void sleep() {
+        System.out.println("菜");
+    }
+
+    @Override
+    public void play() {
+        System.out.println("小狗");
+    }
+}
+```
+
+### 4. 测试类
+
+**文件**：`Test03.java`
+
+```java
+public class Test03 {
+    public static void main(String[] args) {
+        ZhSanOneDay zhSanOneDay = new ZhSanOneDay();
+        zhSanOneDay.myOneDay();
+
+        LiSiOneDay li = new LiSiOneDay();
+        li.myOneDay();
+    }
+}
+```
+
+**预期输出**：
+```
+《我的一天》今天我吃了饭然后我又菜最后我又玩了好开心哟~
+《我的一天》今天我吃了饭然后我又菜最后我又玩了好开心哟~
+```
+
+### 5. 模板方法模式的优势
+
+| 优势 | 说明 |
+|------|------|
+| **复用性** | 公共的流程代码写在父类的模板方法中，所有子类共用 |
+| **扩展性** | 新增一种「一天」只需新建子类，重写抽象方法即可 |
+| **规范性** | 父类通过模板方法强制规定了执行顺序和结构，子类无法改变 |
+| **关注分离** | 使用者只需关心自己的定制逻辑（吃什么/睡什么/玩什么），不用关注整体流程 |
+
+### 6. 模板方法 vs 普通继承 + 方法重写
+
+| 对比维度 | 普通继承 + 方法重写 | 模板方法模式 |
+|---------|-------------------|-------------|
+| **父类方法** | 普通方法，子类可选择重写或不重写 | 模板方法用 `final` 修饰，**禁止重写** |
+| **执行流程** | 由调用方决定调用顺序 | 父类模板方法定义固定执行顺序 |
+| **强制约束** | 弱——子类可以不重写 | 强——子类必须重写抽象方法 |
+| **设计意图** | 复用代码 | 定义算法骨架 + 强制子类实现特定步骤 |
+
+---
+
+## 六、随堂练习要点
 
 **练习目标**：理解抽象类的定义和使用
 
@@ -455,7 +603,7 @@ public class Test {
 
 ---
 
-## 六、面试常见问题
+## 七、面试常见问题
 
 **Q1：抽象类能不能被实例化？**
 > 不能。抽象类不能直接 `new` 创建对象。
@@ -478,9 +626,15 @@ public class Test {
 **Q7：`final` 修饰的类有哪些常见例子？**
 > `String` 类、`Math` 类、`Integer` 等包装类都是用 `final` 修饰的，它们不能被继承。
 
+**Q8：什么是模板方法设计模式？它的核心思想是什么？**
+> 模板方法模式（Template Method Pattern）是抽象类的经典应用场景。核心思想是：**父类定义算法的「骨架」（通用结构），子类实现特定的「步骤」（定制化需求）**。父类中的模板方法用 `final` 修饰禁止重写，抽象方法用 `abstract` 修饰强制子类实现。
+
+**Q9：模板方法模式中，模板方法为什么用 `final` 修饰？**
+> 为了防止子类篡改算法的执行流程。如果模板方法不被 `final` 修饰，子类可以重写它，破坏父类定义好的步骤结构，失去了「模板」的意义。
+
 ---
 
-## 七、拓展阅读
+## 八、拓展阅读
 
 - [Java 抽象类（Oracle 官方文档）](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
 - 抽象类 vs 接口（Interface）的区别（将在后续课程中讲解）