Scala 函数（二）

Scala 函数

Scala中要定义函数，需要给出函数的名称，参数和函数体
def function(x: Double）= if （x > 0 ）x else 0

**必须给出所有参数的类型，不过只要函数不是递归的 ，可以不用指定返回值类型，Scala编译器可以通过=符号右侧的表达式的类型推断出返回类型。
如果函数体需要多个表达式完成，可以用代码块，块中最后一个表达式的值就是函数的返回值
**

package function
/**
  * 函数默认值&带值参数 --> 函数默认值，在调用时传值则使用指定值，不传值则使用默认值
  * 默认值参数 --> 不写返回值自动推断
  * 可变长参数 --> 放在参数列表的最后一位
  * 递归函数--> 指定返回值类型
  */

object Function1 {

  def main(args:Array[String]): Unit = {
	// 标准格式
    // println(function1(1,2))
    // 自动推导返回值类型
    // println(function2(1,2))
    // 可以指定自参数
    // function3(b="Number= ",a = 1)

    // 默认值参数指定一个参数名
	//    function4(age = 19)
    // 对默认值参数进行修改
//    function4("李四",age = 19)


    // 可变长参数
//    val sum = function5("求和：",1,2,3,4,5 )
//    println(sum)


//    val jc1 = jc(5)
//    println(jc1)

  }

  // 递归调用需要给定返回值类型
  def jc(x:Int): Int={
    if(x >= 1){
      x * jc(x-1)
    }else{
      1
    }
  }

  // 可变长参 只能放到参数表最后一位
  def function5(str:String,y:Int*) ={
    var sum = 0;
      for(num <- y){
        sum += num
      }
    sum
  }
  
  // 默认值参数 不写返回值自动推断
  def function4(sex:String = "男",age:Int)={

    println(sex,age)

  }

  // 无返回值 指定参数
  def function3(a:Int,b:String): Unit= {
    print(b,a)
  }


  // 自动推导返回值类型
  def function2(x:Int ,y:Int) ={
    x * y
  }

  // def 方法名(方法参数):返回值类型={
  //     返回
  // }
  def function1(x:Int ,y:Int ):Int={
    x + y
  }

}

过程

Scala 对于不返回值的函数有reshuffle的表示法，如果函数体包含在花括号当中但没有前面的=号，那么返回类型就是Unit。这样的函数被承做过程（procedure）。过程不返回值

package function
object Function1 {

  def main(args:Array[String]): Unit = {
    function12(2,4)
  }

  def function12(x:Int ,y:Int) {
    println(x * y)
  }
}

匿名函数

没有函数名的函数，只有函数体

语法：`(arg1:类型,arg2:类型…) => 函数体

package function

/**
  * 匿名函数
  */
object Function2 {

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

    val demo = (x:Int,y:Int) => x + y

    var demo1 = () => "Hello World"

    println(demo(1,2))

    println(demo1())


    // 匿名函数 标准写法
    val f1:Function2[Int,Int,String] = (x:Int,y:Int) => x + "+"+ y + "="+  + (x + y)

    println(f1(3 ,5))

    // 简便写法

    val f2 = (x:Int,y:Int) => x + "+"+ y + "="+  + (x + y)

    println(f2)
  }
}

柯里化函数（Curring）

柯里化函数指将接受多个参数的函数，改造为接收单个参数的函数，并且返回一个函数对象的过程就称为柯里化

package function

/**
  * 柯里化 函数
  */
object Function03 {

  def main(args: Array[String]): Unit = {
    val demo1 = m2(1)
    println(demo1) // 返回一个 <function1> 对象
    println(demo1(2)) // 3

    val demo2 = m3(1)(_)
    println(demo2) // <function1>
    println(demo2(3)) // 4

    val demo3 = m3(1)(2)
    println(demo3) // 3

  }

  // 柯里化 将原来接收两个参数的函数 转为接收单个参数的函数，并且返回一个函数对象
  def method1(a:Int,b:Int)={
    a + b
  }

  // 柯里化标准写法
  //  def m2(x:Int) = (y:Int) => (z:Int) => x+y+z
  def m2(x:Int) = (y:Int) => x+y

  // 柯里化简便写法

  def m3(x:Int)(y:Int) = x + y

}

懒值lazy

当val被lazy声明时，他的初始化将被延迟，知道我们首次对他进行取值才会进行初始化

// 被lazy 声明
scala> lazy val a = 1 / 0
a: Int = <lazy>
// 首次访问的时候才会执行
scala> println(a)
java.lang.ArithmeticException: / by zero
  at .a$lzycompute(<console>:11)
  at .a(<console>:11)
  ... 32 elided
// 未被lazy修饰，声明的时候就会抛出异常
scala> val b = 1 / 0
java.lang.ArithmeticException: / by zero
  ... 32 elided
scala>

可以理解为懒值是介于 val 和 def 之间的状态
val 是声明的时候取值
lazy 首次访问的时候取值
def 每一次访问的时候都取值