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 }

函式柯里化，其實就是將複雜的引數邏輯變得簡單化,函式柯里化一定存在閉包