方法与函数

1.Scala方法定义

• 1.使用def定义方法
• 2.可以传入参数，但是要指定类型
• 3.返回值类型可写可不写，会自动推断。但是在递归方法、方法返回值类型是函数的时候，必须写
• 4.return可写可不写，会把方法中最后一行的结果返回。
• 5.如果返回值可以一行搞定，{}就可以省略
• 6.如果不写方法名和方法体之间的=，无论计算结果如何，都会被丢弃，只会返回Unit

	/**
    * 定义方法
    */
    //返回值类型：Int
  def max(a:Int,b:Int):Int={
    if (a>b){
      return a
    }else{
      return b
    }
  }
  //返回Int
  def fun(a:Int,b:Int)=a+b
  //无返回值
  def fun1(a:Int,b:Int)={
    println(a-b)
  }

2.递归方法

要显式声明返回值类型

def fun(num:Int):Int={
    if (num==1){
      return 1
    }else{
      return num*fun(num-1)
    }
  }

3.参数有默认值的方法

fun(1,2)：传参个数与方法定义的参数个数相同，新值会覆盖默认值
fun(b=99)：传参个数 < 方法定义的参数个数，只会覆盖部分值

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

4.可变参数

调用：

	fun(1,2,3,4,5)
    fun1(1,"a",3,true)

def fun(s:Int*)={
    println(s)
  }
  def fun1(s:Any*)={
    //遍历
    for(elem<-s){
      println(elem)
    }
    //=>匿名函数的标志
    s.foreach(elem=>println(elem))
    //elem在匿名内部只使用了一次，可以简化为_
    s.foreach(println(_))
    //println也只出现了一次，还能继续简化
    s.foreach(println)
  }

5.匿名函数

和其他方法不同，fun后面的“一坨”赋值给了fun（推断的类型就是(Int,Int)=>Int,这里省略了。当然也能直接写出来，不让它推断：def fun : (Int,Int)=>Int=(a:Int,b:Int)=>{}），最后通过fun传参：fun(1,2)来调用匿名函数。

def fun=(a:Int,b:Int)=>{
    a+b
  }

但是匿名函数不是这么用的。

var f=(s:String)=>{println(s"$s")}
val s=()=>{println("hh")}
val h=(a:Int,b:Int)=>a+b
f("hello")

6.嵌套方法

精髓就是方法中嵌套方法，调用很简单，fun(3)

def fun(a:Int)={
    def sum(b:Int):Int={
      if (b==1){
        1
      }else{
        b+sum(b-1)
      }
    }
    sum(a)
  }

7.偏应用函数

偏应用函数是一种表达式，不需要提供函数所需的所有参数，只需要提供部分、或不提供参数。其中的参数，不变的写前面，变的写后面：_:String。调用的时候直接：showFun(“a”) showFun(“b”) showFun(“c”)

def fun(date:Date,s:String)={
    println(s"$date and $s")
  }
  val date = new Date()
  def showFun=fun(date,_:String)

8.高阶函数

8.1函数的参数是函数

参数是1个函数和一个String。方法的参数中的函数，只定义了类型，并未定义逻辑。

  def fun(f:(Int,Int)=>Int,s:String):String={
    val i = f(10,20)
    i+"#"+s
  }

在调用该方法的时候，通过传参，定义传入匿名函数的逻辑：

fun((a:Int,b:Int)=>{a*b},"hello")

8.2函数的返回是函数

必须显式声明类型，方法定义为：def fun(s:String):(String,String)=>String={}（参数为：(s:String)，返回值为：(String,String)=>String={}）
如果返回结果是加了_，如returnFun _，就无需显式声明类型了：def fun(s:String)={}

def fun(s:String)={
    def returnFun(s1:String,s2:String):String={
      s1+":"+s2+"--->"+s
    }
  returnFun _
}

调用：

fun("1")("a","b")

8.3函数的参数和返回都是函数

参数规定了Int，Int进来，出去Int，返回的函数规定了进来String，String，出去String

def fun(f:(Int,Int)=>Int):(String,String)=>String={
  val i = f(10,20)
  def returnFun(s1:String,s2: String):String={
    s1+":"+s2+"--->"+i
  }
  returnFun
}

调用的时候，声明参数的逻辑以及返回函数的参数a、b：

println(fun((a:Int,b:Int)=>{a*b})("a","b"))

9.柯里化函数

def  func (a:Int,b:Int)(c:Int,d:Int):Int={
    a+b+c+d
  }

调用：

println(func(1,2)(3,4))