feat:线下课代码，Lambda与练习

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))
+  }
+}

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)
+
+  }
+
+}