docs: 更新20260803课堂笔记及README，同步代码变更——扩充Lambda表达式知识点(Demo04新增函数式编程思想/JDK内置函数式接口java.util.function/三条省略规则/使用前提/与匿名内部类区别，Addable+AddableDemo有参有返回值接口单语句省略return，Flyable+FlyableDemo有参无返回值接口单参数省略小括号)并补充练习八与拓展阅读

README.md

@@ -37,7 +37,7 @@
 | 2026-07-29 | [包装类（Wrapper Classes）+ 集合框架入门（Collection Framework）+ 泛型（Generics）：基本类型与包装类对应关系、装箱与拆箱、自动装箱/拆箱、包装类优势、缓存机制、Bean 类应用；集合 vs 数组、体系结构（Collection/List/Set/Map）、线性表数据结构（栈/队列/数组/链表）、ArrayList 底层实现详解（默认容量10、扩容机制、三个构造方法、size vs capacity、trimToSize/ensureCapacity/grow 1.5倍扩容公式、位运算符 >> <<）、ArrayList 常用方法速查；泛型概念与好处、泛型定义格式、通配符 ? / ? extends T、自定义泛型类、有界类型参数、练习参考答案（Student toString/equals/hashCode、泛型 vs 原始类型）](./课堂笔记/01-JavaSE基础-笔记/20260729-笔记.md) |
 | 2026-07-30 | [List.of / LinkedList / 自定义链表 / ArrayList 练习](./课堂笔记/01-JavaSE基础-笔记/20260730-笔记.md) |
 | 2026-07-31 | [LinkedList 多接口形态（List/Queue/Deque）+ Iterator 迭代器 + Map集合（入门/遍历/底层原理）+ 二叉树（二叉搜索树/平衡二叉树/红黑树）](./课堂笔记/01-JavaSE基础-笔记/20260731-笔记.md) |
-| 2026-08-03 | [比较器排序：Comparable 自然排序 / Comparator 比较器排序 + 集合工具类 Collections + 可变参数 Varargs + Lambda 表达式（函数式接口）+ 20260731 课后作业解析（Map 操作与遍历、异常处理综合、匿名内部类 Comparator 排序）](./课堂笔记/01-JavaSE基础-笔记/20260803-笔记.md) |
+| 2026-08-03 | [比较器排序：Comparable 自然排序 / Comparator 比较器排序 + 集合工具类 Collections + 可变参数 Varargs + Lambda 表达式（函数式接口：标准格式/省略模式/JDK 内置函数式接口/与匿名内部类区别）+ 20260731 课后作业解析（Map 操作与遍历、异常处理综合、匿名内部类 Comparator 排序）](./课堂笔记/01-JavaSE基础-笔记/20260803-笔记.md) |
 
 ## 二、授课代码
 
@@ -61,7 +61,7 @@
 | 2026-07-29 | 包装类 + 集合框架入门 + 泛型（Generics）：装箱/拆箱、自动装箱/拆箱、包装类在 Bean 中的应用；集合 vs 数组、体系结构、线性表数据结构、ArrayList 底层实现详解（默认容量10、扩容机制、三个构造方法、size vs capacity、trimToSize/ensureCapacity/grow 1.5倍扩容公式、位移运算符）、ArrayList 常用方法速查；泛型概念与好处、定义格式、通配符、自定义泛型类、有界类型参数、练习参考答案（Student 类重写 toString/equals/hashCode、泛型 vs 原始类型） | `c260729` | [`course/packaging`](./授课代码/c260729/src/course/packaging/) / [`course/collection`](./授课代码/c260729/src/course/collection/) / [`exercises/exercise01`](./授课代码/c260729/src/exericse/exericse01/) / [`exercises/exercise02`](./授课代码/c260729/src/exericse/exericse02/) |
 | 2026-07-30 | List.of() 不可变集合 + LinkedList 双链表理论 + 手写单链表 MyLinked + Student 课程管理练习 (ArrayList 常用操作) + 课后作业回顾手写 MyArrayList | `c260730` | [`course`](./授课代码/c260730/src/course/) / [`exericse/exericse01`](./授课代码/c260730/src/exericse/exericse01/) / [`homework0729/p4`](./授课代码/c260730/src/homework0729/p4/) |
 | 2026-07-31 | LinkedList 多接口形态（List / Queue / Deque）+ Iterator 迭代器遍历（ArrayList/LinkedList 迭代器）+ Map集合：入门（HashMap：put/keySet/values/containsKey）、遍历（keySet+get / entrySet）、HashMap底层原理（数组+链表/红黑树、hashCode/equals、5个关键常量）+ 二叉树（二叉搜索树/平衡二叉树AVL/红黑树规则与旋转）+ 随堂练习参考解答（自定义Key/词频统计） | `c260731` | [`course`](./授课代码/c260731/src/course/) / [`exericse/exericse01`](./授课代码/c260731/src/exericse/exericse01/) / [`exericse/exericse02`](./授课代码/c260731/src/exericse/exericse02/) |
-| 2026-08-03 | 比较器排序：TreeSet/TreeMap 有序集合、Comparable 自然排序（course/Student implements Comparable、compareTo 按年龄二次比较姓名）、Comparator 比较器排序（course/Demo01：TreeSet 构造传入匿名内部类 Comparator）；集合工具类 Collections（course/Demo02：sort/sort+Comparator/reverse/binarySearch/max/min/unmodifiableList/shuffle/fill/swap/rotate/replaceAll + List.of 快速创建集合）；可变参数 Varargs（course/Demo03：add(int... a) 参数个数可变、本质即数组、可变参数必须放最后）；Lambda 表达式（course/Demo04 理论 + Swimming 函数式接口 + SwimmingTest：标准格式(参数)->{代码块}、三要素、匿名内部类 vs Lambda 三种实现方式、接口方法参数传递/变量接收）；20260731 课后作业解析：Map 集合基本操作与遍历（homework0731/p2_map）、异常处理综合（homework0731/p4_exception：自定义异常 InvalidScoreException + 多 catch 块 + 输入校验）、匿名内部类 Comparator 排序（homework0731/p5_sort：Collections.sort 按年龄升序/成绩降序 Double.compare）；随堂练习参考解答（exericse/exericse02：EmployeeSystem 员工管理，compareTo 薪资降序+工号、equals/hashCode 重写、匿名内部类按姓名排序） | `c260803` | [`course`](./授课代码/c260803/src/course/) / [`exericse/exericse02`](./授课代码/c260803/src/exericse/exericse02/) / [`homework0731/p2_map`](./授课代码/c260803/src/homework0731/p2_map/) / [`homework0731/p4_exception`](./授课代码/c260803/src/homework0731/p4_exception/) / [`homework0731/p5_sort`](./授课代码/c260803/src/homework0731/p5_sort/) |
+| 2026-08-03 | 比较器排序：TreeSet/TreeMap 有序集合、Comparable 自然排序（course/Student implements Comparable、compareTo 按年龄二次比较姓名）、Comparator 比较器排序（course/Demo01：TreeSet 构造传入匿名内部类 Comparator）；集合工具类 Collections（course/Demo02：sort/sort+Comparator/reverse/binarySearch/max/min/unmodifiableList/shuffle/fill/swap/rotate/replaceAll + List.of 快速创建集合）；可变参数 Varargs（course/Demo03：add(int... a) 参数个数可变、本质即数组、可变参数必须放最后）；Lambda 表达式（course/Demo04 理论：标准格式(参数)->{代码块}、三要素、函数式编程思想、JDK 内置函数式接口 java.util.function、三条省略规则、使用前提、与匿名内部类区别；Swimming 无参函数式接口 + SwimmingTest 匿名内部类 vs Lambda 三种方式；Addable 有参有返回值接口 + AddableDemo 单语句省略大括号/分号/return；Flyable 有参无返回值接口 + FlyableDemo 单参数省略小括号）；20260731 课后作业解析：Map 集合基本操作与遍历（homework0731/p2_map）、异常处理综合（homework0731/p4_exception：自定义异常 InvalidScoreException + 多 catch 块 + 输入校验）、匿名内部类 Comparator 排序（homework0731/p5_sort：Collections.sort 按年龄升序/成绩降序 Double.compare）；随堂练习参考解答（exericse/exericse02：EmployeeSystem 员工管理，compareTo 薪资降序+工号、equals/hashCode 重写、匿名内部类按姓名排序） | `c260803` | [`course`](./授课代码/c260803/src/course/) / [`exericse/exericse02`](./授课代码/c260803/src/exericse/exericse02/) / [`homework0731/p2_map`](./授课代码/c260803/src/homework0731/p2_map/) / [`homework0731/p4_exception`](./授课代码/c260803/src/homework0731/p4_exception/) / [`homework0731/p5_sort`](./授课代码/c260803/src/homework0731/p5_sort/) |
 
 ## 三、课堂练习题
 

授课代码/c260803/src/course/Addable.java

@@ -0,0 +1,12 @@
+package course;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Addable
+ * @description
+ * @create 2026/8/3
+ */
+public interface Addable {
+    int add(int x,int y);
+}

授课代码/c260803/src/course/AddableDemo.java

@@ -0,0 +1,28 @@
+package course;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title AddableDemo
+ * @description
+ * @create 2026/8/3
+ */
+public class AddableDemo {
+    public static void useAdd(Addable a){
+        int sum = a.add(10, 20);
+        System.out.println(sum);
+    }
+
+    public static void main(String[] args) {
+        /*
+            useAdd( (a,b)->{
+                    return a+b;
+                };
+            );
+
+
+         */
+        //如果代码块的语句只有一条，那么可以省略大括号、分号以及return关键字
+        useAdd( (a,b)->a+b);
+    }
+}

授课代码/c260803/src/course/Demo04.java

@@ -29,6 +29,47 @@ public class Demo04 {
             就像Java当初为了迎合C语言/C++程序员，而推出的基本数据类型一样，
             然后又为了符合面向对象的特性，又搞出包装器类一样，特别拧巴。
 
+         函数式编程和函数式接口
+         在数学中，函数的概念，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
+         面向对象的思想强调的时候“必须通过对象的形式来做事情”
+         函数式编程的思想就是尽量的忽略掉面向对象的复杂写法，强调的时候“做什么”而不是“以什么形式去做”
+         lambda表达式其实就是体现函数式编程思想的一种实现方式。
+
+         函数式接口：就是 接口中只包含一个抽象方法，那么这个接口就是函数式接口。
+         JDK内置的函数式接口：
+         基本都存在java.util.function包中
+         Supplier<T> -->   无参有返回值的接口，返回 T
+         Consumer<T> -->    有参 无返回值的接口，参数类型 T
+         Function<T, R> --> 有参数 有返回值的接口，参数类型T 返回值类型R
+         Predicate<T>  --> 有参数 有返回值，接收参数类型T 返回值类型boolean
+         UnaryOperator<T> --> 有参数 接收T 返回 T
+         BinaryOperator<T> --> 接收参数 T,T 返回 T
+
+        lambda表达式的省略模式：
+            省略的规则：
+                参数类型可以省略，但是如果有多个参数的情况下，不能只省略一个
+                如果参数有且只有一个，那么小括号可以省略
+                如果代码块的语句只有一条，那么可以省略大括号、分号以及return关键字
+
+
+
+        使用lambda表达式的前提：
+            1、使用lambda表达式必须要接口。
+            2、要求接口中有且只有一个抽象方法。
+
+        lambda表达式和匿名内部类有什么区别？
+
+        需要的类型：
+            匿名内部类：可以是接口、抽象类、普通具体类
+            lambda表达式：只能是接口
+        使用限制不同：
+            如果接口有且只有一个抽象方法，可以使用lambda表达式，也可以使用匿名内部类
+            如果接口有多个抽象方法，只能使用匿名内部类，不能使用lambda表达式
+        实现的原理不同：
+            匿名内部类本质上是编译之后会产生一个独立的.class字节码文件
+            lambda表达式，编译之后不会产生单独的.class字节码文件，对应的字节码会在运行的时候动态生成
+
+
 
      */
 }

授课代码/c260803/src/course/Flyable.java

@@ -0,0 +1,12 @@
+package course;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Flyable
+ * @description
+ * @create 2026/8/3
+ */
+public interface Flyable {
+    void fly(String s);
+}

授课代码/c260803/src/course/FlyableDemo.java

@@ -0,0 +1,24 @@
+package course;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title FlyableDemo
+ * @description
+ * @create 2026/8/3
+ */
+public class FlyableDemo {
+    public static void useFlyable(Flyable f) {
+        f.fly("今天天气不错...是风和日丽的...");
+    }
+
+    public static void main(String[] args) {
+        useFlyable(
+                s->{    //如果参数有且只有一个，那么小括号可以省略
+                    System.out.println(s);
+                    System.out.println("长翅膀....飞...");
+                }
+        );
+    }
+
+}

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

@@ -445,12 +445,110 @@ public class SwimmingTest {
 }
 ```
 
+### 函数式编程思想
+
+在数学中，函数就是"有输入量、输出量的一套计算方案"，即**"拿数据做操作"**：
+
+- **面向对象思想**强调"必须通过对象的形式来做事情"
+- **函数式编程思想**则尽量忽略面向对象的复杂写法，强调"**做什么**"而不是"**以什么形式去做**"
+
+**Lambda 表达式就是体现函数式编程思想的一种实现方式。**
+
+### JDK 内置函数式接口（java.util.function 包）
+
+函数式接口：**接口中只包含一个抽象方法**的接口就是函数式接口。JDK 内置了大量函数式接口，基本都存在于 `java.util.function` 包中：
+
+| 接口 | 抽象方法形态 | 说明 |
+|------|--------------|------|
+| `Supplier<T>` | 无参有返回值 | 返回类型 T |
+| `Consumer<T>` | 有参无返回值 | 参数类型 T |
+| `Function<T, R>` | 有参有返回值 | 参数类型 T，返回类型 R |
+| `Predicate<T>` | 有参有返回值 | 参数类型 T，返回值 boolean（断言） |
+| `UnaryOperator<T>` | 有参有返回值 | 接收 T，返回 T（一元运算） |
+| `BinaryOperator<T>` | 有参有返回值 | 接收 T, T，返回 T（二元运算） |
+
+### Lambda 省略模式
+
+Demo04 中总结了三条**省略规则**：
+
+| 省略规则 | 说明 |
+|----------|------|
+| **① 参数类型可以省略** | 但不能"多个参数只省略其中一个"——要么全写，要么全省 |
+| **② 参数有且只有一个，小括号可以省略** | `(s) -> {...}` 可省略为 `s -> {...}` |
+| **③ 代码块的语句只有一条，可以省略大括号、分号以及 return 关键字** | `(a, b) -> { return a + b; }` 可省略为 `(a, b) -> a + b` |
+
+#### 省略模式示例一：有参有返回值接口 Addable
+
+```java
+// 来源：course/Addable.java + AddableDemo.java
+// 有参有返回值的函数式接口
+public interface Addable {
+    int add(int x, int y);
+}
+
+public class AddableDemo {
+    public static void useAdd(Addable a) {
+        int sum = a.add(10, 20);
+        System.out.println(sum);
+    }
+
+    public static void main(String[] args) {
+        // 完整写法：
+        // useAdd((a, b) -> {
+        //     return a + b;
+        // });
+
+        // 省略写法：代码块只有一条语句 → 省略大括号、分号、return 关键字
+        useAdd((a, b) -> a + b);   // 两个参数 → 小括号不能省略
+    }
+}
+```
+
+#### 省略模式示例二：有参无返回值接口 Flyable
+
+```java
+// 来源：course/Flyable.java + FlyableDemo.java
+// 有参无返回值的函数式接口
+public interface Flyable {
+    void fly(String s);
+}
+
+public class FlyableDemo {
+    public static void useFlyable(Flyable f) {
+        f.fly("今天天气不错...是风和日丽的...");
+    }
+
+    public static void main(String[] args) {
+        // 参数有且只有一个 → 小括号可以省略：s -> {...}
+        useFlyable(s -> {
+            System.out.println(s);
+            System.out.println("长翅膀....飞...");
+        });
+    }
+}
+```
+
+### Lambda 使用前提
+
+使用 Lambda 表达式有两个**必须满足**的前提：
+1. **必须要有接口**——Lambda 的本质是简化接口的匿名实现
+2. **接口中有且只有一个抽象方法**——即必须是函数式接口
+
+### Lambda 与匿名内部类的区别
+
+| 对比维度 | 匿名内部类 | Lambda 表达式 |
+|----------|-----------|---------------|
+| **需要的类型** | 可以是**接口、抽象类、普通具体类** | **只能是接口** |
+| **使用限制** | 接口有多个抽象方法也能用 | **必须只有一个抽象方法**（函数式接口） |
+| **实现原理** | 编译后产生一个**独立的 `.class` 字节码文件** | 编译后**不产生单独的 `.class` 文件**，字节码在运行的时候**动态生成** |
+
 ### 关键理解
 
 1. **Lambda = 匿名内部类的简化形式**：因为 `Swimming` 接口里**只有一个**需要重写的抽象方法，所以 `()` 能指向的就只有这一个抽象方法，`->` 指向的就是重写抽象方法的代码块内容。
 2. **使用前提**：Lambda 只能简化**函数式接口**（只有一个抽象方法），多抽象方法接口用 Lambda 会编译报错。
 3. **三要素对应**：`(形式参数)` → 重写方法的参数列表；`->` → 指向动作；`{代码块}` → 重写方法的方法体。
-4. **与匿名内部类的联系**：本节第 3 节 Comparator 正是用匿名内部类实现的，后续可以用 Lambda 进一步简化——如 `Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge())`。
+4. **省略模式记忆口诀**：类型可全省、单参可省括号、单语句可省大括号/分号/return。
+5. **与匿名内部类的联系**：本节第 3 节 Comparator 正是用匿名内部类实现的，后续可以用 Lambda 进一步简化——如 `Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge())`。
 
 ---
 
@@ -774,6 +872,19 @@ public class Student {
 2. 为什么 Lambda 只能用在**只有一个抽象方法**的接口上？—— 只有一个待重写方法，`()` 才能唯一确定指向它
 3. 本节第 3 节的 Comparator 匿名内部类能否改写成 Lambda？—— 可以，如 `(o1, o2) -> o1.getAge() - o2.getAge()`，后续 Stream 也会大量使用
 
+### 练习八：Lambda 省略模式与 JDK 内置函数式接口
+
+**核心步骤**：
+1. 定义**有参有返回值**函数式接口 `Addable`（`int add(int x, int y)`），用 Lambda 实现 `useAdd((a, b) -> a + b)`——验证"单语句省略大括号/分号/return"
+2. 定义**有参无返回值**函数式接口 `Flyable`（`void fly(String s)`），用 Lambda 实现 `s -> {...}`——验证"单参数省略小括号"
+3. 改写 Comparator：`Collections.sort(list, (s1, s2) -> s1.getAge() - s2.getAge())`，观察省略后的极简写法
+4. 查阅 `java.util.function` 包，说出 `Supplier / Consumer / Function / Predicate` 四个接口的形态
+
+**思考**：
+1. 三条省略规则分别是什么？—— 参数类型可全省（不能只省一个）、单参数可省小括号、单语句可省大括号/分号/return
+2. 为什么 `(a, b) -> a + b` 能省略 return？—— 代码块只有一条语句且是表达式时，表达式结果自动作为返回值
+3. Lambda 与匿名内部类的本质区别是什么？—— 匿名内部类编译产生独立 .class 文件；Lambda 编译不产生 .class，运行期动态生成字节码
+
 ### 随堂练习参考解答（已提供代码）
 
 对应今日课堂练习的参考解答已写入授课代码：
@@ -854,6 +965,7 @@ treeSet = new TreeSet<>(new Comparator<Employee>() {
 - [可变参数 Varargs（Oracle 教程）](https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html#varargs)
 - [Lambda 表达式（Oracle 教程）](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
 - [函数式接口（Oracle 教程）](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#functional)
+- [java.util.function 包 (JDK 17)](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/package-summary.html)
 - [RuntimeException (JDK 17)](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/RuntimeException.html)
 
 ### 推荐阅读
@@ -861,12 +973,14 @@ treeSet = new TreeSet<>(new Comparator<Employee>() {
 - 《Java 核心技术 卷 I》第 9 章 集合 —— 排序与比较器
 - 《Effective Java》第 3 版 第 14 条：考虑实现 Comparable 接口
 - 《Java 编程思想》第 17 章 容器深入研究 —— 哈希码与排序
+- 《Java 8 实战》第 3 章 Lambda 表达式 —— 行为参数化、函数式接口、方法引用
 
 ### 相关知识点
 
 | 前置知识 | 当前知识 | 后续知识 |
 |----------|----------|----------|
 | 匿名内部类（0727） | Lambda 表达式 / 函数式接口 | Stream 流、方法引用 |
+| 接口与多态（0723/0724） | JDK 内置函数式接口（java.util.function） | 方法引用、Stream 高阶函数 |
 | 集合体系与泛型（0729） | TreeSet / TreeMap 有序集合 | 红黑树底层（0731 已讲） |
 | HashMap 基本操作（0731） | Map 综合练习（keySet/entrySet 遍历） | Map 与 Set 的互转、分组统计 |
 | 异常处理（0728） | 自定义异常 + 多 catch 块 | 异常链、try-with-resources |