From d08ecade11e5dfe4ff347c1007234c1d1aa91664 Mon Sep 17 00:00:00 2001
From: kennethcheng <a1478925630@163.com>
Date: Sun, 13 Sep 2026 16:09:54 +0800
Subject: [PATCH] =?UTF-8?q?feat:=E7=BA=BF=E4=B8=8B=E8=AF=BE=E4=BB=A3?=
 =?UTF-8?q?=E7=A0=81=EF=BC=8CLambda=E4=B8=8E=E7=BB=83=E4=B9=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/scala/chapter2/demo3/AddF.scala      | 11 ++++
 .../scala/chapter2/demo3/DemoLambda.scala     | 62 +++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 src/main/scala/chapter2/demo3/AddF.scala
 create mode 100644 src/main/scala/chapter2/demo3/DemoLambda.scala

diff --git a/src/main/scala/chapter2/demo3/AddF.scala b/src/main/scala/chapter2/demo3/AddF.scala
new file mode 100644
index 0000000..51535c2
--- /dev/null
+++ b/src/main/scala/chapter2/demo3/AddF.scala
@@ -0,0 +1,11 @@
+package chapter2.demo3
+
+object AddF {
+  def main(args: Array[String]): Unit = {
+    def add(a: (Int, Int) => Int): Int = {
+      a(10, 20)
+    }
+
+    println(add((x, y) => x + y))
+  }
+}
diff --git a/src/main/scala/chapter2/demo3/DemoLambda.scala b/src/main/scala/chapter2/demo3/DemoLambda.scala
new file mode 100644
index 0000000..2514042
--- /dev/null
+++ b/src/main/scala/chapter2/demo3/DemoLambda.scala
@@ -0,0 +1,62 @@
+package chapter2.demo3
+
+object DemoLambda {
+
+  def main(args: Array[String]): Unit = {
+    def add(z: Int, y: Int): Int = {
+      return z + y
+    }
+
+    // 实现了add函数功能的匿名函数
+    val addLambda: (Int, Int) => Int = (x: Int, y: Int) => x + y
+    // lambda表达式的类型可以自动推断，所以addLambda1可以不定义类型（自动推断）
+    val addLambda1 = (x: Int, y: Int) => x + y
+    // 因为addLambda2的类型已经确定了，所以后面的参数的类型可以省略，以为从类型定义中可以明确了
+    val addLambda2: (Int, Int) => Int = (x, y) => x + y
+
+    //    (Int, Int) => Int  (类型)  Int,String
+    println(addLambda(1, 2))
+
+
+    // 函数作为参数
+    def func(test: (Int, Int) => Int, a: Int, b: Int): Unit = {
+      println(s"传入了两个数：$a,$b，他们的作用后的结果是${test(a, b)}")
+    }
+
+
+    func(addLambda, 10, 20)
+
+    val minusLambda: (Int, Int) => Int = (x, y) => x - y
+    func(minusLambda, 10, 20)
+
+    // 一次性使用的匿名函数，那么不需要定义变量指向它
+    func((x: Int, y: Int) => x * y, 10, 20)
+
+    def f0(f1:String => Unit):Unit = {
+      f1("test")
+    }
+    f0((name:String)=> println(name))
+    // 这里的name我并不关心是什么类型，总之就是把他打印了，那么我们可以省略掉lambda表达式的参数类型的定义
+    // 实际上在f0的定义中，已经确定了lambda表达式的参数类型是什么
+    //    val test:String => Unit = (name)=> println(name + "lambda表达式")
+    f0((name)=> println(name))
+
+    // lambda表达式只有一个参数，并且类型被省略了，那么括号也可以省略
+    f0(name => println(name))
+
+
+    // 这个name在后面的代码中只被使用了一次，那其实它叫什么名字都无所谓
+    //    f0( _ => println( _ ))
+    // 参数和函数体中的引用，只有一次，那么参数也可以省略了
+    f0( println( _ ))
+    // 如果在f0的调用中，能确定println是一个函数体，而不是调用语句，那么 ( _ ) 可以省略
+    f0(println)
+
+    // 不能直接写f0()，因为我不知道你要做什么操作
+    // f0()
+
+    f0(println)
+
+  }
+
+}