【Scala】03 函数

1、Scala的方法语法：

object Hello {
  def main(args : Array[String]) : Unit = {

    // scala 允许在方法的声明中再声明方法，并且调用
    def someFunction(x : Int, y : String): Unit = {
      println("this function has been called! （In this main method）")
    }

    // 调用方法中声明的
    someFunction(100, "str")

    // 调用这个对象声明的
    val returnVal = Hello.someFunction(2, "ol")
  }

  // 在对象中也可以声明方法，支持和方法中重名
  def someFunction(x : Int, y : String): Int = {
    println("this function has been called! （In this single instance）")
    return 100
  }
}

2、参数和返回值

    // 没有参数 没有返回值
    def method01(): Unit = {
      print("method01")
    }
    // 有参数 没有返回值
    def method02(x : Int, y : String): Unit = {
      print("method02")
    }
    // 有参数 有返回值
    def method03(x : Int, y : String): Int = {
      print("method01")
      return 100
    }
    // 没有参数 有返回值
    def method04(): Int = {
      return 300
    }

3、参数特性

// 在参数类型后面加上*号表示该参数是可变参数
def method(str : String*): Unit = {
  println(str)
}
method("hello", "scala") // 打印结果是一个数组序列 ArraySeq(hello, scala)

// 多个参数必须将可变参数放在最后一个
def method2(x : Int, y : Double, string: String*): Unit = {

}

// 默认参数
def method3(name : String = "这是默认值"): Unit = {
  println(name)
}

method3() // 这样无参也可以被调用，因为已经设定了一个默认值在这里 C++是支持这种操作的
method3("jojo")

// 带名参数，这个参数的意思是，你可以在调用的时候强制指定注入的参数是给哪个参数的
def method4(name : String, age : Int, gender : Boolean): Unit = {

}
// 带名参数的意义就在于支持打乱顺序入参
method4(gender = true, name = "张三", age = 30) 

4、函数特性：

// Lambda表达式特性

// 1、可以省略return，Scala支持 函数体的最后一段代码最为返回的结果
def f0(str : String) : String = {
  str // 这里就省略的了 return
}
println(f0("param"))

// 2、函数体只有一段代码可以省略阔话表示
def f1(str : String) : String = str

// 3、如果类型可以推断出来，则不需要强制声明返回类型是什么
def f2(str : String) = str

// 4、写了Return就必须声明返回类型
def f3(str : String) : String = return str

// 5、明确了返回类型为Unit，则 return没有任何意义
def f4(str : String) : Unit = return str // 这个str无意义

// 6、Unit返回类型 可以直接向Java一样声明
def f5(str : String) {
  println(str)
}

// 7、没有参数，但是声明的时候写了，调用可以没有括号，加括号也行
def f6() {
  println("str")
}
f6() // 这样调用正常
f6 // 这样调用也没问题

// 8、如果声明的时候就没有参数列表，调用绝不能写括号
def f7 {
  println("str")
}
f7 // 调用正常
// f7() // 这样调用编译报错

// 如果不关心名称，只需要逻辑处理，这里也可以匿名声明
(name : String) => {
  println(name)
}

5、函数可以作为参数注入

    val funcRef = (string : String) => {
      println(string)
    }

    // 定义一个函数，参数可以是一个函数
    def funcForFunc(function: String => Unit): Unit = {
      function("asdas");
    }

    // 这里很奇怪的一点是，参数为什么可以在里面注入，而外面只需要声明入参数函数？
    funcForFunc(funcRef)

    // 我有点想明白了，这样的话，参数是顶死的，但是允许套用不同的方法，只要方法符合这个参数的方法类型要求即可被套用

    // 语法缩写

    // 1、参数类型可以省略不写，只要能够被推导出来
    funcForFunc((name) => {println(name)})

    // 2、参数只有一个可以不写参数括号
    funcForFunc(name => {println(name)})

    // 3、执行的语句只有一行可以不写花括号表示
    funcForFunc(name => println(name))

    // 4、参数只使用过一次的情况，可以不声明参数了，直接使用下划线表示
    funcForFunc(println(_))

    // 5、最后是调用推断
    funcForFunc(println)

用法案例介绍：

    // 定义一个二元运算的函数，只操作固定的1和2个值，具体的运算由注入的函数实现
    def calcForThis(fun : (Int, Int) => Int) : Int = {
      fun(100, 200)
    }

    val sum = (a : Int, b : Int) => a + b
    val minus = (a : Int, b : Int) => a - b
    val max = (a : Int, b : Int) => if (a > b) a else b
    val min = (a : Int, b : Int) => if (a > b) b else a


    // 调用
    val s = calcForThis(sum)
//    val s = calcForThis(minus)
//    val s = calcForThis(max)
//    val s = calcForThis(min)

    // 匿名函数简化

    // 原始完整调用
    println(calcForThis((a : Int, b : Int) => a + b))
    // 对匿名简化
    println(calcForThis((a, b) => a + b))
    // 参数简化
    println(calcForThis( _ + _))

这和Java或者之前学习的编程不太一样

我们创建各种方法，是为了对参数进行处理，方法是为了封装逻辑

现在感觉是反过来，参数是既定的，封装的成方法了，这个感觉写起来像那个接口的感觉一样

6、函数的进一步操作

    // 1、在函数体中声明函数，然后又调用函数
    def foo() {
      println("foo ...")
    }
    foo()

    // 2、作为值进行传递
    def foo2() : Int =  {
      100
    }
    val res = foo2()  // 将函数的返回值传递给 res
    val res2 = foo2() _ // 将函数自己作为值传递给 res2
    val res3:() => Int = foo2 // 如果明确变量类型? 可以不使用下划线将函数作为整体传递给参数


    // 3、函数入参 作为函数参数
    def subjectFunction(paramFunction : (Int, Int) => Int): Int = {
      paramFunction(100, 314) // subjectFunction 主体函数， paramFunction参数函数
    }
    subjectFunction(_ + _)
    subjectFunction(_ * _)

    // 4、函数作为返回值返回
    def f1() = { // 声明外层一个f1函数
      def f2() = { // 在内层中声明一个f2函数

      }
      f2 _ // 并且返回f2这个函数
    }
    val s = f1() // 调用就是把f2函数传递给s

7、对集合的一些处理操作

    // 对数组进行操作，如何操作作为一个抽象来定义，处理完毕返回一个新的数组
    def arrOp(arr : Array[Int], op : Int => Int) : Array[Int] = {
      for (elem <- arr) yield op(elem)
    }

    // 声明一个加一操作
    def increaseOne(elem : Int) = {
      elem + 1
    }

    // 使用
    val sourceArr = Array(1, 10, 30, 100) // 声明一个原始的数组
    val newArr = arrOp(sourceArr, increaseOne) // 注意这里给方法的时候是把方法本身传递，而不是调用
    println(newArr.mkString(","))

    // 简化调用
    val newArr2 = arrOp(sourceArr, _ + 1) 

8、案例练习：

    // 声明匿名函数给fun变量
    val fun = (a : Int, a2 : String, a3 : Char) => {
      if(a == 0 && a2 == "" && a3 == '0') false
      else true
    }

    // 调用
    println(fun(0, "", '0'))

9、初见柯里化

    // 但是这段声明的语法看不太懂
    def func(i: Int): String => (Char => Boolean) = {
      def f1(s : String) : Char => Boolean = {
        def f2(c : Char) : Boolean = {
          if(i == 0 && s == "" && c == '0') false
          else true
        }
        f2
      }
      f1
    }

    // 简写
    def func2(i: Int): String => (Char => Boolean) = {
      (s : String)  => {
        (c : Char) => {
          if(i == 0 && s == "" && c == '0') false else true
        }
      }
    }
    // 最外层有声明参数类型，也可以被省略
    def func3(i: Int): String => (Char => Boolean) = {
      s => c => if(i == 0 && s == "" && c == '0') false else true
    }
    // 柯里化？
    def func4(i: Int)(s: String)(c : Char):Boolean = {
      if(i == 0 && s == "" && c == '0') false else true
    }

    // 这里肯定看不懂
    println(func(0)("")('0'))

    // 这样来拆解出来 是这样调用的，只是没有变量接受，直接匿名进行调用了
    val resultFunction1 = func(0)
    val resultFunction2 = resultFunction1("")
    val res = resultFunction2('0')
    println(res)

10、案例：

    // 闭包 & 柯里化

    // 闭包概念 ： 一个函数，访问了外部的局部变量的值，这个函数和所在的范围称为闭包
    // 意义在于外部函数知晓完毕出栈之后，需要保留部分的参数内容，给内部函数进行计算和调用

    // 案例 将固定加数作为另一个参数传入，但是是作为第一层参数传入
    def addByParam():Int => Int = {
      val a = 4
      def addByPa2(b : Int): Int = {
        a + b
      }
      addByPa2
    }

    def addByParam2(a:Int):Int => Int = {
      def addByPa2(b : Int): Int = {
        a + b
      }
      addByPa2
    }

    def addByParam3(a:Int):Int => Int = a + _
    // 柯里化 把一个参数列表的多个参数，变成多个参数列表
    val res = addByParam2(39)(42)

    def addCurrying(a : Int)(b : Int) = {
      a + b
    }
    addCurrying(39)(42)

11、递归 Recursive

    /**
     * Scala的递归
     * 1、方法调用的是自身
     * 2、必须存在可以结束的逻辑
     * 3、参数应该有规律
     * 4、递归必须声明返回类型
     */
    // 阶乘案例
    def factorial(n : Int): Int = {
      if (n == 0) return 1
      factorial(n - 1) * n
    }

    // 尾递归
    def tailFact(n : Int)= {
      def loop(n : Int, currRes : Int) : Int = {
        if (n == 0) return currRes
        loop(n - 1, currRes * n)
      }
      loop(n, 1)
    }

12、抽象控制

    // 控制抽象

    /**
     * 这里演示一段Java写法
     */
    val a = 100 // 声明一个常量
    def someFunction(s : Int) = { // 声明函数
      println(s)
    }
    someFunction(100) // 一般来说就是直接注入实际可见的值
    someFunction(a) // 或者是变量

    /**
     * Scala 希望不出现这些变量和字面值
     * 因为函数代表了一切内容
     */
    def returnTen() = 10
    someFunction(returnTen()) // 要以这种方法来进行入参的表达方式，就是控制抽象

13、传名参数

    // 传名参数，强调的是参数是一段代码块，执行包括代码块中的内容
    def fun(a : => Int) = {
      println(s"a : ${a}")
      println(s"a : ${a}")
    }

    def f1() = {
      println("f1 called")
      12
    }

    // 使用
    fun(f1()) // f1被调用了两遍 a即表示函数，出现一次调用一次

    fun(23) // 为什么可以传递23？

    /**
     * 因为23就是一个函数的返回
     */
    () => 23

14、实现自定义循环的案例

    // 实现自定义循环
    def customWhile(condition : Boolean):(=> Unit)=> Unit= {
      def doCustomLoop (operate : => Unit): Unit = {
        if (condition) {
          operate
          customWhile(condition) (operate)
        }
      }
      doCustomLoop _
    }

    // 柯里化表达
    def customWhile2(condition: => Boolean)(operate: => Unit): Unit = {
      if (condition) {
        operate
        customWhile2(condition)(operate)
      }
    }

    var n = 10
    customWhile2(n > 0) {
      println(n)
      n -= 1
    }

15、懒加载处理

    val sum = (a : Int,b : Int) => {
      println("sum has been called")
      a + b
    }
    val minus = (a : Int,b : Int) => {
      println("minus has been called")
      a - b
    }

    val result1 : Int = minus(11, 31)
    // 惰性加载
    lazy val result2 : Int = sum(11, 31)

    println("- - - 函数应该被调用了 - - -")
    println(s"函数应该被调用了 ${result2} ${result1}")