Scala函数

基础函数

函数

def 方法名（参数名:参数类型,参数名:参数类型...）:返回值类型{
方法主体
}

object FunctionDemo {
  def main(args: Array[String]): Unit = {
    //def 定义声明  main方法名  args 形参 ：后是数据类型 ：unit是返回值类型
def minvalue(a:Int,b:Int):Int={//求最小值函数
if(a>b) b else a
}
}

递归函数

10！

//第一种：传统方法循环
def ji(a:Int):Int={
val result=1
for(i<-a to 1 by -1){
result=i*result
}
result
}

//第二种：递归
def ji(a:Int):Int={
if(a==1) 1 else a*def(a-1)
}

/*指定形参名字，传参
 通过*来指定未知长度的参数
 当不知道要传几个参数时，可以加*号，*表示可以传多个参数*/
 def showMsg(name:String,s:String*):unit={}
 showMsg("a","b","c"..)

//Scala函数允许指定参数的缺省值，从而允许在调用函数时不指明该参数
//可以在定义类型的时候指定参数，调用的时候就可以不用传参
def printName(first: String = "hello", last: String = "scala") = {
  println(first + " " + last)
}
printName()

hello scala

匿名函数

指不含函数名称的函数
匿名函数定义：(参数名:参数类型...)=>{函数体}
如果函数体包括多条语句，应使用{ }包含

 def sum(a:Int,b:Int):Int = a+b
    val abc =(a:Int,b:Int) => a+b
    val bac=abc
    println(abc(1, 3))
    println(bac(2, 2))
    println(sum(10, 3))
    val a    :   String             =   "jij"
    val b    :   Int                =    32
    val ab   :   (Int,Int)=>Int     =    (a:Int,b:Int)=>a+b
    val ba   :   (Int,Int)=>Int     =    ab
    val abc1 :   (Int,Int)=>Int     =    sum

函数作为参数传递

def test(f:(Int,Int)=>Int,msg:String):String={
val a=1
val b=2
msg+f(a,b)
}
def sum(i1:Int,i2:Int):Int=i1+i2
println(test(sum,"和为："))
println(test((a:Int,b:Int)=>a+b,"和为:"))

和为：3
和为：3

函数柯里化

def fun(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
}
println(fun(1,2,3,4))
println(fun2(1,2)(3,4))
println(fun3(1,2,3)(4))
println(fun4(1)(2)(3)(4))

10
10
10
10

隐式化

隐式参数

class FunctionDemo
object FunctionDemo{
implicit var d=4
def fun(a:Int)(b:Int)(c:Int)(implicit d:Int):Int={
a+b+c+d
}
println(fun(1)(2)(3))
}

10

implicit var n1: Int = 10
    implicit var s1: String = "yyy"

    def f2(num: Int)(implicit num2: Int): Int = {
      num + num2
    }

    def f3(name: String)(implicit name2: String): String = {
      name + name2
    }

    println(f2(20)(40))
    println(f3("sss"))

60
sssyyy

调用fun函数时，只输入了前三个参数，最后一个参数是自动调用前面定义的implicit var d=4,这就是隐式参数
调用方法的时候优先级比较， 传参 > 隐式 > 默认(隐式函数定义在另一个包的类中，通过导包传入）
同一域内不能出现两个隐式参数

隐式方法

object ImplicitCase{
implicit var d=4
implicit def stringToInt(value:String):Int=Integer.parseInt(value)
implicit def doubleToInt(value:Double):Int=value.toInt
implicit def intToString(value:Int):String=value.toString
var a:Int="4"
var b:Int=3.3
var c:String=2
}

隐式类

object implicitCase{
implicit class test2(demo:test){
def sum(a:Int,b:Int):Int={
println("a value:"+a)
println("b value:"+b)
a+b
}
def ji(a:Int,b:Int):Int={
a*b
}
}}

import implicitCase._
class test
object test{
val test=new Test
println(test.sum(1,2))
println(test.ji(3,4))
}

3
12