Scala之 函数式编程三 *

文字有点多

文字有点多,放一起会很卡,所以分开放了.
​​​Scala之 函数式编程 一​​

​​​Scala之 函数式编程 二​​​​​​

​​Scala之 函数式编程 三​​

高阶函数

在Scala里面函数可以定义在任意一个位置,比如说在函数内定义函数.这个在函数内定义的函数就是局部函数

一个函数可以返回函数或者是接收函数,那么这个函数就是高阶函数

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

    //高阶函数————函数作为参数
    def calculator(a: Int, b: Int, operater: (Int, Int) => Int): Int = {
      operater(a, b)
    }

    //函数————求和
    def plus(x: Int, y: Int): Int = {
      x + y
    }

    //方法————求积
    def multiply(x: Int, y: Int): Int = {
      x * y
    }

    //函数作为参数
    println(calculator(2, 3, plus))
    println(calculator(2, 3, multiply))
  }

在外部调用函数内部的函数

def main(args: Array[String]): Unit = {
    val f1: () => Unit = foo()
    f1() //在外部调用函数内部的函数
  }

  def foo() = {
    def f() = {
      println("aaa")
    }

    f _ //将内部函数返回出去
  }

函数和方法区别

函数可以作为值传递,可以是入参,也可以是返回值,而方法不行,

真正用的时候 函数和方法也不会细分

如果我们用def定义的东西就是方法.不能叫函数.

如果用val接收了一下这个方法,那么这个方法就变成了函数.

方法转成函数

def main(args: Array[String]): Unit = {
    // 这里就是函数了
    val f = foo _ // 把方法转成了函数

    f(10) // 函数执行
    foo(10) // 方法执行

  }

  //这里就是方法
  def foo(a: Int) {
    return println(a)
  }

输出:

10
10

方法转成函数案例2

def main(args: Array[String]): Unit = {
    // 把方法转成了函数, 没有环境, 所以必须手动转换
    val add1 = add _
    // 这个时候也是在把方法转成了函数, 但是是scala自动完成
    val add2: (Int, Int) => Int = add
    println(add1(10, 20))
    println(add2(10, 20))

  }
  // 方法
  def add(a: Int, b: Int): Int = {
    return a + b;
  }

定义和使用函数

=>左面是参数类型,=>右面是返回值类型

// 直接定义函数,函数不能声明返回值类型, 只能靠推导
    () => {}

使用函数

// 定义一个函数,用int作为参数同时用int作为返回值
      val f: Int => Int = (a: Int) => a * a
      val r: Int = f(10)
      println(r)

输出:

100

把方法当成函数传递

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

    val r: Int = foo(add) //把方法当函数传递
    println(r)
  }

  def foo(op: (Int, Int) => Int) = {
    op(10, 20)
  }

  def add(a: Int, b: Int) = a + b

输出

30

匿名函数

1. 匿名函数:
   没有名字的函数, 就是匿名函数
   用处:
   1. 作为实参, 直接传递给高阶函数
   2. 直接作为高阶函数的返回值
2. 传递:
   foo((a:Int, b:Int) => a + b)
3. 在传递匿名函数的时候, 参数的类型一般可以利用上下文, 让scala去自动推导
4. foo(_ + _)
   要求: 1. 匿名只能有两个参数
   2. 每个参数只使用了一次
   3. 第一个_表示第一个参数, 第二个下划线表示第二个参数

传统函数和匿名函数对比

def main(args: Array[String]): Unit = {
    val a = () => println("传统函数")
    foo(a)

    // 匿名函数
    foo(() => {
      println("匿名函数")
    })

  }

  def foo(f: () => Unit) = {
    f()
  }