Scala函数详细介绍

Scala函数
函数是Scala的核心

//函数的定义
def 函数名[参数列表]:[返回值类型]={
    函数体
    return[表达式]
 }
 //函数调用
 函数名[参数列表]

命名参数

//通常情况下，传入的参数与函数定义的参数列表应一一对应
def printName(first:String, last:String) = {
    println(first + " " + last)
}
printName("John","Smith")
//也允许使用任意顺序传入参数
printName(first = "John",last = "Smith")
printName(last = "Smith",first = "John")

**参数缺省值

def printName(first:String="John", last:String="Smith") = {
    println(first + " " + last)
}
printName()

匿名函数
指的是不含函数名称的函数
=>右边为参数列表，=>左边为函数体

(x:Int)=>x*x
(x:Int)=>{println(x);x*x}
() => { System.getProperty("user.dir") }
val f1=(x:Int)=>{println(x);x*x}
f1(2)

函数作为参数进行传递

def fun(a:Int,b:Int):Int=a+b
//定义一个匿名函数f作为funTest的参数
def funTest(f:(Int,Int)=>Int,s:String):String={
   //给匿名函数传参
   val resultValue=f(2000,3000)
   //返回值
   s+resultValue
   }
   //给funtest函数传参数时候，可以借用fun函数的函数体给匿名函数f使用，前提是参数列表和返回值类型一致
   println( funTest(fun,"你的工资是") )
   //也可以自己给f函数重新写一个函数体
   println( funTest((a:Int,b:Int)=>a+b,"你的工资是") )

函数作为返回值

def funTest2():(String,String)=>String={
    def fun1(str1:String,str2:String):String={
    str1+str2
    }
    fun1
}
    println( funTest2()("你的姓名是","某某某") )    

函数作为参数，作为返回值

def funMsg(f:(String)=>Int,Str:String):(Int:Int)=>Int={
    var intNum=f(str)
    if(intNum%3==0){
      (a:Int,b:Int)=>a+b
    }else{
      (a:Int,b:Int)=>a-b
    }
}
  val result=funMsg((s:String)=> if(s.equals("上海")) 3 else 0,"上海")(1000,2000)
  println(result)

柯理化
方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化

def fun1(a:Int,b:Int,c:Int,d:Int):Int=a+b+c+d
def fun2(a:Int)(b:Int,c:Int,d:Int):Int=a+b+c+d
def fun3(a:Int)(b:Int)(c:Int,d:Int):Int=a+b+c+d
def fun4(a:Int,b:Int)(c:Int,d:Int):Int=a+b+c+d
//传入相同参数时候结果是一样的

隐式参数
方法可以具有隐式参数列表，由参数列表开头的implicit 关键字标记
implict只能修改最尾部的参数列表，应用于其全部参数
Scala可自动传递正确类型的隐式值
通常与柯里化函数结合使用

implicit var a:Int=10 //将作为Int类型隐式值自动传递
def sum(a:Int,b:Int)(implicit c:Int):Int=a+b+c
sum(10,20) // 40
implicit var str:String="结果 "
def sum(a:Int,b:Int)(implicit c:Int,str:String):String={
    str+(a+b+c)
}
sum(10,20) // 结果 40

隐式函数
隐式函数也称隐式转换，使用implicit修饰的函数

//类型转换
implicit def doubleToInt(a:Double):Int={a.toInt}
val a:Int=3.5 //我们定义的a是Int类型，但是输入的数字是Double类型，却不会报错，因为此时a已经不等于3.5而是3
println(a) //3
//类型增强
implicit def booleanToInt(x:Boolean):Int=if(x) 1 else 0
println(1+true) //2

scala中case

//类型匹配
def match2(x:Any):Unit=x match {
  case a:Int=>println("输入的值类型为Int类型,值为："+a)
  case s:String=>println("输入的值类型为String类型,值为："+s)
  case _=>println("我布吉岛")
}
//模式匹配
case class Teacher(name:String,age:Int)
def match3(teacher: Teacher):Unit=teacher match {
  case Teacher("Tom",19)=>println("hello,Tom")
  case Teacher("Black",21)=>println("hello,Black")
  case x:Teacher=>{println("hello,"+x.name)}
}