Scala 函数闭包和柯里化

 1 package com.atguigu.function
 2
 3 object HighFunction {
 4   def main(args: Array[String]): Unit = {
 5     /*    val fun = (x: Int, y: String, z: Char) => {
 6         if (x==0 && y=="" && z=='0'){
 7           true
 8         }else{
 9           false
10         }
11     }
12     println(fun(0,"",'1'))*/
13
14     /*
15       练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。
16       它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接
17       收一个 Char 类型的参数，返回一个 Boolean 的值。
18       要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。
19      */
20     def func(x: Int) = {
21       def f1(y: String) = {
22         println("我是f1！")
23
24         def f2(z: Char): Boolean = {
25           println("我是f2！")
26           if (x == 0 && y == "" && z == '0') false else true
27         }
28         f2 _
29       }
30
31       f1 _
32     }
33
34 //    func(1)("")('1')
35   }
36
37   println("```````````````````````````")
38
39   def f1() = {
40     var a: Int = 10
41
42     def f2(b: Int) = {
43       a + b
44     }
45
46     f2 _
47   }
48
49   // 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
50   val f = f1()
51   // 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果
52   println(f(3))
53   println(f1()(3))
54
55   //闭包
56   /*
57     addByFour函数：
58     内部定义一个局部变量a 固定值是4
59     函数的返回值是一个嵌套函数，完成a+b的操作，当外部调用时，addByFour()(2)只需要控制第二个形参的数值
60     而第一个加数永远是4，相当于固定了一个参数
61    */
62   def addByFour(): Int => Int = {
63     val a = 4
64
65     def addB(b: Int): Int = {
66       a + b
67     }
68
69     addB
70   }
71   println("结果是：" + addByFour()(3)) //4+3
72 }

 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包

1   //函数柯里化：把一个参数列表的多个参数，变成多个参数列表 也就是fun(a,b,c) -> fun(a)(b)(c) 分层函数调用
2   def addCurry(a : Int)(b:Int):Int ={
3     a+b
4   }
5   println("柯里化："+addCurry(34)(23))