docs: 更新20260723课堂笔记，同步代码变更——新增接口（Interface）：接口引出（解决单继承局限）、接口定义与成员特点、implements实现、USB接口标准示例（Usb→LogiMouse/ROGMouse）、接口vs抽象类对比

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 vs abstract 对比；模板方法设计模式（Template Method Pattern）：模板类组成（final 模板方法 + abstract 定制方法）、MyOneDayTemplate 示例（ZhSanOneDay / LiSiOneDay）、模板方法 vs 普通继承+重写对比；代码块（局部代码块/构造代码块/静态代码块的定义、执行时机、执行顺序验证、构造代码块提取公共代码）；随堂练习（Shape 抽象类计算周长+面积）](./课堂笔记/01-JavaSE基础-笔记/20260723-笔记.md) |
+| 2026-07-23 | [抽象类（abstract）+ final 关键字 + 模板方法设计模式 + 代码块 + 接口（Interface）：抽象类引出与概念、抽象类定义（abstract 关键字）、抽象类特点（不能实例化/可有构造方法/子类必须重写所有抽象方法或自身抽象）、抽象类代码示例（Animal→Cat/Dog / Emp→javaEmp / BaseService→UserService）；final 修饰类/方法/变量（常量全大写命名规范）、final 引用类型、final vs abstract 对比；模板方法设计模式（Template Method Pattern）：模板类组成（final 模板方法 + abstract 定制方法）、MyOneDayTemplate 示例（ZhSanOneDay / LiSiOneDay）；代码块（局部/构造/静态三种代码块的定义、执行时机与顺序验证）；接口（Interface）：接口引出（解决单继承局限性）、接口定义与成员特点（变量 public static final、方法 public abstract）、implements 关键字、接口 vs 抽象类对比、USB 接口标准示例（Usb→LogiMouse/ROGMouse 继承 Mouse 并实现 Usb）、接口多实现与接口多继承；随堂练习（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）：抽象类概念与引出、抽象类定义、抽象类特点、抽象类代码示例（Animal→Cat/Dog / Emp→javaEmp / BaseService→UserService）、Test01 测试类；final 关键字（final 类/方法/变量/引用类型、常量全大写规范、Test02 测试 final 行为）；模板方法设计模式——MyOneDayTemplate（final 模板方法 myOneDay + 抽象方法 eat/sleep/play，ZhSanOneDay / LiSiOneDay 子类实现，Test03 测试）；代码块——Demo04.java（局部代码块/构造代码块/静态代码块的定义、执行顺序） | `c260723` | [`course`](./授课代码/c260723/src/course/) |
+| 2026-07-23 | 抽象类（abstract）：抽象类概念与引出、抽象类定义、抽象类特点、抽象类代码示例（Animal→Cat/Dog / Emp→javaEmp / BaseService→UserService）、Test01 测试类；final 关键字（final 类/方法/变量/引用类型、常量全大写规范、Test02 测试 final 行为）；模板方法设计模式——MyOneDayTemplate（final 模板方法 myOneDay + 抽象方法 eat/sleep/play，ZhSanOneDay / LiSiOneDay 子类实现，Test03 测试）；代码块——Demo04.java（局部代码块/构造代码块/静态代码块的定义、执行顺序）；接口（Interface）：接口引出（解决单继承局限性）、接口定义与成员特点（MyInterface 示例）、implements 关键字、USB 接口标准（Usb 接口 + Mouse 父类 + LogiMouse/ROGMouse 继承 Mouse 实现 Usb，Test04 测试）、接口多实现与接口多继承 | `c260723` | [`course`](./授课代码/c260723/src/course/) |
 
 ## 三、课堂练习题
 

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

@@ -0,0 +1,64 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo05
+ * @description 接口
+ * @create 2026/7/23
+ */
+public class Demo05 {
+    /*
+        Java中的继承是单继承，一个子类只能直接继承一个父类
+        这种方式逻辑非常清晰，但是也有弊端，因为只能继承一个父类，扩展性就比较低。比如出现如下情景：
+
+        学生类 extends 人类
+
+        鹦鹉 extends 鸟类
+
+        鸟人 extends ？
+
+        Java中为了解决单继承来的局限性问题，提出了 接口 的概念
+
+        接口是一种公共规范标准，只要符合这个规范标准，大家都可以通用。
+
+        鸟人 extends 人类 实现 飞行接口
+
+        Java接口存在的意义：
+            用来定义规范
+            用来做功能的拓展
+
+        接口的关键字：interface
+        接口也是一种引用数据类型， 或者说接口也是一种类
+        接口中的所有的方法 都是 公共的 抽象方法 默认都是使用 public abstract 修饰
+        接口中的所有的变量 都是 公共的、静态的、常量 都是使用 public static final 修饰的
+        public interface 接口名{
+
+
+        }
+        接口的子类 我们称为【实现类】，因为这个类严格来讲不是继承接口
+        而是遵循接口的规范，实现（重写）接口的所有抽象方法。
+
+        子类 继承 接口 我们称为  实现 接口
+        子类 extends 父类
+        实现类 实现 接口
+        实现类实现接口的关键字： implements
+        public class 实现类 implements 接口{
+
+        }
+
+        接口是不能实例化的，也就是不能创建对象
+
+        接口的子类：
+            要么重新接口里所有的抽象方法
+            要么子类也是一个抽象类
+
+        接口不存在构造方法， 也就不能创建对象。
+
+        java中的类 虽然只能继承一个父类，但是可以同时实现多个接口。
+
+        Java中的接口和接口之间是可以多继承的。一个子接口可以继承多个父接口
+
+     */
+}

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

@@ -0,0 +1,31 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title LogiMouse
+ * @description 罗技鼠标
+ * @create 2026/7/23
+ */
+public class LogiMouse extends Mouse implements Usb{
+
+    public LogiMouse(String brand, double price) {
+        super(brand, price);
+    }
+
+    @Override
+    public void startUsb() {
+        System.out.println("罗技鼠标启动");
+    }
+
+    @Override
+    public void useUsb() {
+        System.out.println("罗技鼠标使用");
+    }
+
+    @Override
+    public void stopUsb() {
+        System.out.println("罗技鼠标关闭");
+    }
+}

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

@@ -0,0 +1,39 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Mouse
+ * @description 鼠标类
+ * @create 2026/7/23
+ */
+public class Mouse {
+    private String brand;
+    private double price;
+
+    public Mouse(String brand, double price) {
+        this.brand = brand;
+        this.price = price;
+    }
+
+    public String getBrand() {
+        return brand;
+    }
+
+    public void setBrand(String brand) {
+        this.brand = brand;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+
+    public void showInfo(){
+        System.out.println("品牌："+brand+"，价格："+price);
+    }
+}

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

@@ -0,0 +1,20 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title MyInterface
+ * @description
+ * @create 2026/7/23
+ */
+public interface MyInterface {
+
+
+
+    //接口中定义的变量，默认都是使用public static final  公开的静态常量
+    public static final String name="张三";
+
+    //接口中定义的所有方法，默认都是使用 public abstract 修饰的
+    public abstract void method();
+}

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

@@ -0,0 +1,30 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title ROGMouse
+ * @description ROG鼠标
+ * @create 2026/7/23
+ */
+public class ROGMouse extends Mouse implements Usb{
+    public ROGMouse(String brand, double price) {
+        super(brand, price);
+    }
+
+    @Override
+    public void startUsb() {
+        System.out.println("ROG鼠标启动");
+    }
+
+    @Override
+    public void useUsb() {
+        System.out.println("ROG鼠标使用");
+    }
+
+    @Override
+    public void stopUsb() {
+        System.out.println("ROG鼠标关闭");
+    }
+}

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

@@ -0,0 +1,19 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Test
+ * @description
+ * @create 2026/7/23
+ */
+public class Test04 {
+    public static void main(String[] args) {
+        LogiMouse lm=new LogiMouse("罗技",13.6);
+        lm.showInfo();
+        lm.startUsb();
+        lm.useUsb();
+        lm.stopUsb();
+    }
+}

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

@@ -0,0 +1,19 @@
+package course;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Usb
+ * @description
+ * @create 2026/7/23
+ */
+public interface Usb {
+
+    void startUsb();
+
+    void useUsb();
+
+    void stopUsb();
+
+}

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

@@ -703,9 +703,260 @@ public class Example {
 }
 ```
 
-## 七、随堂练习要点
+## 七、接口（Interface）
 
-**练习目标**：理解抽象类的定义和使用
+### 1. 接口的引出——解决单继承的局限性
+
+**文件**：`Demo05.java`
+
+Java 中的继承是 **单继承**，一个子类只能直接继承一个父类。这种方式逻辑清晰，但扩展性较低。
+
+```
+学生类 extends 人类
+
+鹦鹉   extends 鸟类
+
+鸟人   extends   ？    ← 既有人类的特征，又有鸟类的飞行能力，单继承无法解决
+```
+
+为了解决单继承带来的局限性，Java 提出了 **接口** 的概念。
+
+**接口（Interface）** 是一种公共规范标准，只要符合这个规范标准，大家都可以通用。
+
+```
+鸟人 extends 人类 实现 飞行接口    ← 继承父类 + 实现接口，两者互补
+```
+
+**接口存在的意义**：
+- **定义规范** — 规定实现类必须遵循的行为标准
+- **功能拓展** — 在继承父类的基础上，额外扩展其他能力
+
+> 俗话说的好：「**单继承 + 多实现**」——一个类只能继承一个父类，但可以同时实现多个接口。
+
+### 2. 接口的定义
+
+**文件**：`Demo05.java`、`MyInterface.java`
+
+接口的关键字是 `interface`。接口也是一种引用数据类型（或者说接口也是一种类）。
+
+```java
+public interface 接口名 {
+    // 成员
+}
+```
+
+**接口的成员特点**：
+
+| 成员类型 | 默认修饰符 | 说明 |
+|---------|-----------|------|
+| **变量** | `public static final` | 接口中定义的变量都是 **公开的静态常量** |
+| **方法** | `public abstract` | 接口中定义的方法都是 **公开的抽象方法** |
+
+```java
+public interface MyInterface {
+    // 变量——默认使用 public static final
+    public static final String name = "张三";
+
+    // 方法——默认使用 public abstract
+    public abstract void method();
+}
+```
+
+> **注意**：接口和抽象类一样 **不能实例化**（不能创建对象），且接口 **没有构造方法**。
+
+### 3. 接口的实现
+
+**文件**：`Demo05.java`
+
+子类继承接口称为「**实现** 接口」，使用关键字 `implements`。
+
+```java
+public class 实现类 implements 接口 {
+    // 必须重写（实现）接口中所有的抽象方法
+}
+
+// 类可以同时继承父类 + 实现接口
+public class 子类 extends 父类 implements 接口1, 接口2, ... {
+    // 必须重写所有接口中的抽象方法
+}
+```
+
+**接口的子类（实现类）规则**：
+- 要么重写（实现）接口中 **所有** 的抽象方法
+- 要么子类也是一个 **抽象类**
+
+**接口与抽象类的对比**：
+
+| 对比维度 | 抽象类 | 接口 |
+|---------|-------|------|
+| **关键字** | `abstract class` | `interface` |
+| **构造方法** | 可以有 | 不能有 |
+| **成员变量** | 可以是任意类型 | 只能是 `public static final` 常量 |
+| **成员方法** | 可以有抽象/非抽象方法 | 只能是 `public abstract` 抽象方法 |
+| **子类方式** | `extends`（继承） | `implements`（实现） |
+| **单/多** | 单继承 | 可同时实现多个接口 |
+
+### 4. USB 接口标准示例
+
+#### 4.1 定义 USB 接口标准
+
+**文件**：`Usb.java`
+
+```java
+package course;
+
+public interface Usb {
+    void startUsb();   // 默认 public abstract
+    void useUsb();     // 默认 public abstract
+    void stopUsb();    // 默认 public abstract
+}
+```
+
+USB 接口定义了一个规范标准：任何 USB 设备都必须具备「启动 → 使用 → 关闭」三个行为。
+
+#### 4.2 父类 Mouse
+
+**文件**：`Mouse.java`
+
+```java
+public class Mouse {
+    private String brand;
+    private double price;
+
+    public Mouse(String brand, double price) {
+        this.brand = brand;
+        this.price = price;
+    }
+    // getter/setter 省略...
+    public void showInfo() {
+        System.out.println("品牌：" + brand + "，价格：" + price);
+    }
+}
+```
+
+#### 4.3 实现类 LogiMouse（罗技鼠标）
+
+**文件**：`LogiMouse.java`
+
+```java
+// 继承父类 Mouse + 实现 Usb 接口
+public class LogiMouse extends Mouse implements Usb {
+
+    public LogiMouse(String brand, double price) {
+        super(brand, price);
+    }
+
+    @Override
+    public void startUsb() {
+        System.out.println("罗技鼠标启动");
+    }
+
+    @Override
+    public void useUsb() {
+        System.out.println("罗技鼠标使用");
+    }
+
+    @Override
+    public void stopUsb() {
+        System.out.println("罗技鼠标关闭");
+    }
+}
+```
+
+#### 4.4 实现类 ROGMouse（ROG 鼠标）
+
+**文件**：`ROGMouse.java`
+
+```java
+public class ROGMouse extends Mouse implements Usb {
+    public ROGMouse(String brand, double price) {
+        super(brand, price);
+    }
+
+    @Override
+    public void startUsb() {
+        System.out.println("ROG鼠标启动");
+    }
+
+    @Override
+    public void useUsb() {
+        System.out.println("ROG鼠标使用");
+    }
+
+    @Override
+    public void stopUsb() {
+        System.out.println("ROG鼠标关闭");
+    }
+}
+```
+
+#### 4.5 测试类 Test04
+
+**文件**：`Test04.java`
+
+```java
+public class Test04 {
+    public static void main(String[] args) {
+        LogiMouse lm = new LogiMouse("罗技", 13.6);
+        lm.showInfo();   // 调用父类 Mouse 的方法
+        lm.startUsb();   // 实现 Usb 接口的抽象方法
+        lm.useUsb();     // 实现 Usb 接口的抽象方法
+        lm.stopUsb();    // 实现 Usb 接口的抽象方法
+    }
+}
+```
+
+**预期输出**：
+```
+品牌：罗技，价格：13.6
+罗技鼠标启动
+罗技鼠标使用
+罗技鼠标关闭
+```
+
+### 5. 继承与接口的实现关系图
+
+```
+        ┌──────────┐          ┌──────────┐
+        │  Mouse   │          │   Usb    │
+        │ (父类)   │          │ (接口)   │
+        └────┬─────┘          └────┬─────┘
+             │ extends             │ implements
+    ┌────────┴──────────┐          │
+    │                   │          │
+┌───┴────────┐   ┌──────┴─────┐    │
+│ LogiMouse  │   │  ROGMouse  ├────┘
+│ extends    │   │  extends   │
+│ Mouse      │   │  Mouse     │
+│ implements │   │  implements│
+│ Usb        │   │  Usb       │
+└────────────┘   └────────────┘
+```
+
+### 6. 接口的补充特性
+
+**文件**：`Demo05.java`
+
+- **类与接口**：一个类虽然只能继承一个父类，但是可以同时 **实现多个接口**
+- **接口与接口**：接口之间可以 **多继承**（一个子接口可以继承多个父接口）
+
+```java
+// 类实现多个接口
+public class MyClass implements InterfaceA, InterfaceB, InterfaceC {
+    // 必须重写所有接口中的抽象方法
+}
+
+// 接口继承多个接口
+public interface SubInterface extends InterfaceA, InterfaceB {
+    // 子接口继承多个父接口的方法
+}
+```
+
+---
+
+## 八、随堂练习要点
+
+**练习目标**：理解抽象类、接口、代码块的基本使用
 
 1. **定义抽象父类**：使用 `public abstract class` 声明，定义抽象方法时不要写方法体
 2. **实现具体子类**：使用 `extends` 继承抽象类，使用 `@Override` 重写所有抽象方法
@@ -713,7 +964,7 @@ public class Example {
 
 ---
 
-## 八、面试常见问题
+## 九、面试常见问题
 
 **Q1：抽象类能不能被实例化？**
 > 不能。抽象类不能直接 `new` 创建对象。
@@ -748,11 +999,24 @@ public class Example {
 **Q11：构造代码块有什么作用？**
 > 构造代码块可以把多个构造方法中共同的代码提取出来，避免重复。每次创建对象时，构造代码块会在构造方法之前自动执行，无论调用的是哪个重载的构造方法。
 
+**Q12：接口和抽象类有什么区别？**
+> ① 关键字不同：抽象类是 `abstract class`，接口是 `interface`；② 构造方法：抽象类可以有，接口不能有；③ 成员变量：抽象类可以是任意类型，接口只能是 `public static final` 常量；④ 成员方法：抽象类可以有抽象/非抽象方法，接口只能是 `public abstract` 抽象方法；⑤ 子类方式：抽象类用 `extends` 继承，接口用 `implements` 实现；⑥ 单/多：抽象类是单继承，接口可以同时实现多个。
+
+**Q13：一个类可以同时继承一个父类并实现多个接口吗？**
+> 可以。Java 中的类虽然只能单继承（一个父类），但可以同时实现多个接口。格式：`public class 子类 extends 父类 implements 接口1, 接口2 { ... }`。
+
+**Q14：接口中的变量默认使用什么修饰符？方法呢？**
+> 接口中的变量默认使用 `public static final` 修饰（公开的静态常量），方法默认使用 `public abstract` 修饰（公开的抽象方法）。
+
+**Q15：接口为什么不能实例化？接口有构造方法吗？**
+> 接口没有构造方法，因此不能实例化（不能创建对象）。接口是一种规范标准，需要通过实现类来提供具体的功能实现。
+
 ---
 
-## 九、拓展阅读
+## 十、拓展阅读
 
 - [Java 抽象类（Oracle 官方文档）](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+- [Java 接口（Oracle 官方文档）](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
 - [Java 代码块初始化（Oracle 官方文档）](https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html)
-- 抽象类 vs 接口（Interface）的区别（将在后续课程中讲解）
+- 抽象类 vs 接口（Interface）的区别对比
 - 模板方法设计模式（Template Method Pattern）—— 抽象类的经典应用场景