Scala方法和函数

1.Scala方法的定义

  def fun (a: Int , b: Int ) : Unit = {
    println(a+b)
  }
  fun(1,1)

  def fun1 (a : Int , b : Int)= a+b
  println(fun1(1,2))

• 方法定义语法 用def来定义
• 可以定义传入的参数，要指定传入参数的类型
• 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归方法中或者方法的返回值是函数类型的时候。
• scala中方法有返回值时，可以写return，也可以不写return，会把方法中最后一行当做结果返回。当写return时，必须要写方法的返回值。
• 如果返回值可以一行搞定，可以将{}省略不写
• 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。
• 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。

2.递归方法

/**
  * 递归方法 5的阶乘
  */
def fun2(num: Int): Int = {
  if (num == 1)
    num
  else
    num * fun2(num - 1)
}
print(fun2(5))

3.参数有默认值的方法

• 默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值
• 如果不想覆盖默认值，传入的参数个数小于定义的函数参数个数，则需要指定参数名称

4.可变参数的方法

/**
  * 可变参数个数的函数
  * 注意：多个参数逗号分开
  */
def fun4(elements: Int*) = {
  var sum = 0;
  for (elem <- elements) {
    sum += elem
  }
  sum
}
println(fun4(1, 2, 3, 4))

5.匿名函数

/**
  * “=>” 就是匿名函数，多用于方法的参数是函数时
  * 注意：可以将匿名函数返回给定义的一个变量
  */
//有参数匿名函数
val value1 = (a: Int) => {
  println(a)
}
value1(1)
//无参数匿名函数
val value2 = () => {
  println("hello world")
}
value2()
//有返回值的匿名函数
val value3 = (a: Int, b: Int) => {
  a + b
}
println(value3(4, 4)) 

6.嵌套方法

/**
  * 嵌套方法
  * 例如：嵌套方法求5的阶乘
  */
def fun5(num: Int) = {
  def fun6(a: Int, b: Int): Int = {
    if (a == 1) {
      b
    } else {
      fun6(a - 1, a * b)
    }
  }
  fun6(num, 1)
}
println(fun5(5))

7.偏应用函数

    /**
      * 偏应用函数
      * 某些情况下，方法中参数非常多，调用这个方法非常频繁，每次调用只有固定的某个参数便变化，可以定义偏应用函数来实现
      */
        def showLog(date: Date, log: String): Unit = {
          println(s"date is $date , log is $log")
        }

        val date = new Date()
        showLog(date, "a")
        showLog(date, "b")
        showLog(date, "c")

        def fun: String => Unit = showLog(date, _: String)
        fun("a")
        fun("b")
        fun("c")

8.高阶函数

  /**
      * 高阶函数
      * 1）方法的参数是函数
      * 2）方法的返回时函数 必须显式的返回函数类型 或者 使用“_” 来当返回值来返回
      * 3）方法的参数和返回都是函数
      */
//函数的参数是函数
def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
  f(a,100)
}
def f(v1 :Int,v2: Int):Int  = {
  v1+v2
}
println(hightFun(f, 1))

//函数的返回是函数
//1，2,3,4相加
def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
  def f2 (v1: Int,v2:Int) :Int = {
    v1+v2+a+b
  }
  f2
}
println(hightFun2(1,2)(3,4))

//函数的参数是函数，函数的返回是函数
def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
  f
}
println(hightFun3(f)(100,200))
println(hightFun3((a,b) =>{a+b})(200,200))
//以上这句话还可以写成这样
//如果函数的参数在方法体中只使用了一次 那么可以写成_表示
println(hightFun3(_+_)(200,200))

9.柯里化函数

/**
  * 柯里化函数
  */
def fun7(a :Int,b:Int)(c:Int,d:Int) = {
  a+b+c+d
}
println(fun7(1,2)(3,4))