函数进阶

a的n次方

object Base49 {
  // 递归计算a的n次方
  def power(a: Double, n: Int): Double = {
    // 基准情况
    if (n == 0) 1.0
    // 负数次方的情况
    else if (n < 0) 1 / power(a, -n)
    // 正数次方的递归情况
    else a * power(a, n - 1)
  }

  def main(args: Array[String]): Unit = {
    // 测试示例
    println(power(2, 3))   // 8.0
    println(power(5, 0))   // 1.0
    println(power(3, -2))  // 0.111...
    println(power(2.5, 2)) // 6.25
  }
}

字面量语法1

object Base50 {
  // 定义一个函数，计算两数的和
  def sum(x: Int, y: Int): Int = {
    x + y
  }
  //字面量语法，看起来像给变量赋值
  val sum1 = (x: Int, y: Int) => {x + y}

  def main(args: Array[String]): Unit = {
    val a = 2
    val n = 5
    println(s"$a + $n = ${sum1(a,n)}")
  }
}

字面量语法2

object Base51 {
  // 定义一个函数，计算两数的和
  def sum(x: Int, y: Int): Int = {
    x + y
  }
  //字面量语法，看起来像给变量赋值
  val sum1 = (x: Int, y: Int) => {x + y}
    /*
    要点：
    1 有一个箭头符号 =>
    2 省略def，忽略了返回值类型
    特殊的写法--简写
    1 函数只有一串代码，可省略{}
    2 如果参数只使用了一次，可以用_来代替。要加上参数的类型
     */
    val sum2 = (x: Int, y: Int) => x + y
  val sum3 :(Int,Int) => Int = {_+_}
  val sum4 = (_: Int) + (_:Int)

  def main(args: Array[String]): Unit = {
    val a = 2
    val n = 5
    println(s"$a + $n = ${sum1(a,n)}")
    println(s"$a + $n = ${sum2(a,n)}")
    println(s"$a + $n = ${sum3(a,n)}")
    println(s"$a + $n = ${sum4(a,n)}")
  }
}

字面量语法3

object Base52 {
  // 定义一个函数，计算两数的和
  //定义一个字面量函数，计算两个数的较大者
  val getMax = (x: Int, y: Int) => if(x>y) x else y
  //定义一个字面量函数，计算两个数的较小者
  val getMin = (x: Int, y: Int) => if(x<y) x else y

  //test这个函数，他的第一个参数是一个函数
  val test = (x:(Int,Int)=>Int, a:Int,b:Int ) => {
    println("test被调用")
    println(x(a,b) )
  }
  def main(args: Array[String]): Unit = {
   test(getMax,1,2)
  }
}

object Base53 {
  //部分应用函数，在调用函数的时候，只传入一部分函数。
  val mul = (a:Int,b:Int,c:Int) => a*b*c

  def main(args: Array[String]): Unit = {
    val rst = mul(2,3,4)
    val f = mul(2,3,_)//第三个参数传入一个_,表示：这个参数先空着，也不能返回最后的计算结果。
    var rst1 = f(5)//mul(2,3,5)
    println(rst)
    println(rst1)
  }
}