Scala学习（五）函数式编程

函数式编程

• 面向对象编程：解决问题，分解对象，行为，属性，然后通过对象的关系 以及行为的调用来解决问题
• 函数式编程：解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。
• 函数和方法的区别：
  • 函数：为了完成某一个功能的程序语句的集合，称之为函数
    • 函数没有重载和重写的概念
  • 方法：类中的函数称之为方法
    • 方法可以进行重载和重写
      
• 类中的函数称之为方法所以可以重载和重写，但是方法中的函数就不行，因为函数不支持重载和重写

object TestFunction {
  // (2)方法可以进行重载和重写，程序可以执行
  def main(): Unit = {
  }

  def main(args: Array[String]): Unit = {
    // （1）Scala 语言可以在任何的语法结构中声明任何的语法
    import java.util.Date
    new Date()

    // (2)函数没有重载和重写的概念，程序报错
    def test(): Unit = {
      println("无参，无返回值")
    }

    test()

    def test(name: String): Unit = {
      println()
    }
    //（3）Scala 中函数可以嵌套定义
    def test2(): Unit = {
      def test3(name: String): Unit = {
        println("函数可以嵌套定义")
      }
    }
  }
}

函数基础

函数基本语法

1. 基本语法
   

函数定义

• 函数 1：无参，无返回值

 // 函数 1：无参，无返回值
 def test1(): Unit ={
 println("无参，无返回值")
 }
 test1()

• 函数 2：无参，有返回值

 // 函数 2：无参，有返回值
 def test2():String={
 return "无参，有返回值"
 }
 println(test2())

• 函数 3：有参，无返回值

 // 函数 3：有参，无返回值
 def test3(s:String):Unit={
 println(s)
 }
 test3("jinlian")

• 函数 4：有参，有返回值

 // 函数 4：有参，有返回值
 def test4(s:String):String={
 return s+"有参，有返回值"
 }
 println(test4("hello "))

• 函数 5：多参，无返回值

 // 函数 5：多参，无返回值
 def test5(name:String, age:Int):Unit={
 println(s"$name, $age")
 }
 test5("dalang",40)

• 函数 6：多参，有返回值

 // 函数 6：多参，有返回值
 def test6(a:Int, b:Int):Int={
 println("6. 多惨，有返回值")
 return a + b
 }
 test6(12,40)

函数参数

• 可变参数
  

• 如果参数列表中存在多个参数，那么可变参数一般放置在最后，因为如果可变参数放到前面的话，就不好检测第二个参数
  

• 参数默认值，一般将有默认值的参数放置在参数列表的后面
  

• 带名参数
  

函数至简原则

• return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
• 如果函数体只有一行代码，可以省略花括号
• 返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
• 如果有 return，则不能省略返回值类型，必须指定
• 如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
• Scala 如果期望是无返回值类型，可以省略等号
• 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
• 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
• 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

函数高级

高阶函数

1. 函数可以作为值及进行传递

    val test = (name:String) => {println(name)}
    test("wrq")

2. 函数可以在作为参数进行传递

    val test = (name:String) => {println(name)}
    test("wrq")

    println("---------------------------------")

    def test2(a:String => Unit):Unit={
      a("zjf")
    }

    test2(test)

等价于

3. 函数可以作为函数返回值返回

def main(args: Array[String]): Unit = {
  def f1() = {
    def f2() = {
    }
    f2 _
  }
  val f = f1()
  // 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
  f()
  // 上面的代码可以简化为
  f1()()
}

匿名函数

• 说明：没有名字的函数就是匿名函数 (x:Int)=>{函数体} (x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑)

    //定义一个二元运算函数，只能操作a和b两个数
    def dualFunctionOneAndTwo(fun:(Int,Int) => Int, a:Int, b:Int):Int={
      fun(a,b)
    }

    val add = (a:Int,b:Int) => a+b
    val minus = (a:Int, b:Int) => a-b

    println(dualFunctionOneAndTwo(add,1,2))
    println(dualFunctionOneAndTwo(minus,3,4))

• 匿名函数的至简原则
  • 参数的类型可以省略，会根据形参进行自动的推导
  • 类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
  • 匿名函数如果只有一行，则大括号也可以省略
  • 如果参数只出现一次，则参数省略且后面参数可以用_代替

    test2(test)
    test2((name:String) => {println(name)})
// （1）参数的类型可以省略，会根据形参进行自动的推导
    test2((name) => {println(name)})
// （2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
    test2(name => {println(name)})
// （3）匿名函数如果只有一行，则大括号也可以省略
    test2(name => println(name))
// （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    test2(println(_))

• 匿名函数练习：

//练习1：
//    定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。
//    要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。
    val fun = (a:Int,b:String,c:Char) => {
      if (a == 0 && b.equals("") && c == '0')
        false
      else
        true
    }
    println(fun(0,"",'0'))
    //练习2：函数作为返回值
//    定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。
//    它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接
//    收一个 Char 类型的参数，返回一个 Boolean 的值。
//    要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。
    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 func(i: Int): String => (Char => Boolean) = {
      s => c => if (i == 0 && s == "" && c == '0') false else true
    }
    //柯里化
    def func(i: Int)(s:String)(c:Char):Boolean = {
      if (i == 0 && s == "" && c == '0') false else true
    }
    println(func(0)("")('0'))

函数柯里化和闭包

1. 闭包：如果一个函数，访问到它的外部变量的值，那么这个函数和他所在的环境，称为闭包
2. 函数柯里化：把一个参数列表的多个参数，变成多个参数列表。
3. 代码演示：

    object TestFunction {
      def main(args: Array[String]): Unit = {
        def f1()={
          var a:Int = 10
          def f2(b:Int)={
            a + b
          }
          f2 _
        }
        // 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
        val f = f1()
        // 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形
        成了闭合的效果
        println(f(3))

        println(f1()(3))
        // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存
        在闭包
        def f3()(b:Int)={
          a + b
        }
        println(f3()(3))
      }
    }
        

递归

• 一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

    //递归：求n!的阶乘
    def fact(n:Int):Int = {
      if(n == 0)
        return 1
      fact(n-1) * n
    }

    println(fact(4))

控制抽象

1. 值调用：把计算后的值传递过去
2. 名调用：把代码传递过去

    //值传递
    def f(a:Int):Unit = {
      println(a)
    }
    //名传递
    def k(a: =>Unit):Unit={
      println(a)
    }
    f(1)
    k(f(1))
        //综合联系：自己写一个while函数
    def myWhile(condition: =>Boolean): (=>Unit) => Unit = {
      //内层递归调用函数
      def doLoop(op: =>Unit):Unit ={
        if(condition){
          op
          myWhile(condition)(op)
        }
      }
      doLoop _
    }
    var n = 10
    myWhile(n >= 1)({
      println(n)
      n -= 1
    })

惰性加载

• 当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行，这种函数称之为懒性函数

    //懒加载
    def main(args: Array[String]): Unit = {
      lazy val res = sum(10, 30)
      println("----------------")
      println("res=" + res)
    }
    def sum(n1: Int, n2: Int): Int = {
      println("sum 被执行。。。")
      return n1 + n2
    }