scala函数，柯里化函数

scala中函数没有重载的概念，函数名称唯一，不区分参数，
scala是完全面向对象，也是完全面向函数

根据函数的最后一行推断返回类型：

def test():String={
print(1111)
"Hello world"
}

这时候可以省略返回类型
如果函数体只有一行代码，大括号可以省略

def test():String = "Hello word "

如果函数的声明没有参数列表，小括号可以省略：

def test = "Hello World"

但是这样访问的时候不能增加小括号，只能用 test访问 （统一访问方式）
如果加上()调用的时候可以用 test() 或者 test
方法不加 = 的时候，表示函数没有返回值（与unit不同）

def test (){
"Hello world"
}

或者

def test {
"Hello world"
}

调用的时候必须用 test
编译器不会把最后一行返回，明确没有返回值

可变参数：

def test(name :String*):Unit={}

可传人一个

默认参数：

def test(name:String ,age:Int=20):Unit={}

scla中函数可以赋值给变量，可以作为函数的参数，可以作为函数的返回值

def f():Unit={
println("Hello world")
}

def f0={
// f 这样写的话会有问题， 无参的函数这种是默认调用，写成如下格式
f _ //增加特殊符号 _ 下划线
}

可以写成如下格式： 柯里化函数可以这么写：

def f1(i:Int){								def f(i:Int)(j:Int):Int={
def f0(j:Int):Unit={							i*j
i*j								   }
}									 	print(f(2)(3))
f _
}
println(fo(2)(3))

函数闭包

一个函数在实现逻辑时，将外部变量引入到函数内容，改变了这个变量的生命周期，
将函数作为参数传递给另外一个函数，采用特殊的声明， ()=>Unit 参数列表=>返回值类型

val f:(Int)=>Int = f1(10)
def f4(f:()=>Int):Int={
f()+10
}
def f5():Int={
5
}

匿名函数：

def f6(f:(Int)=>Unit):Unit{
f(10)
}
f6(
(i:Int )=>{println(s"Hello world $i"}
)

i可以推导，可以类型类型：

f6(
(i )=>println(s"Hello world $i"）}
)
f6(
(i )=>println(s"Hello world $i"）
)

只有一个参数只使用一次的时候，可以省略如下：

f6(
println(_)
)

还可以省略如下：

f6(
println
)

def f7(f:(Int,Int)=>Int):Int{
f(10,10)
}
println(f7((x:Int,y:Int)=>{x+y})
println(f7((x,y)=>{x+y})
println(f7((x,y)=>x+y)
println(f7(_+_)   //注意这里下划线是表示这两个参数只使用了一次，第一个_表示x,第二个 _ 表示y

def f1="hello world" 是一个函数，相当于：

def f1():String={
"hello world"
}

参数类型推断

参数推断省去类型信息，参数类型是可以推断出来的，也可以进行相应的简写，相应规则如下

• 参数类型可以推断时，省略参数类型
• 传入的函数只有单个参数时，可以省去括号
• 如果变量只在 => 右边出现一次，可以用 _ 代替

函数如果参数只有一行，且有且只有一个参数并且只是用一遍的时候可以省略
：

list.foreach((i:Int)=>{println(i)})
list.foreach((i)=>{println(i)})
list.foreach({println(_)})
list.foreach(println(_))
list.foreach(println)

函数柯里话

在函数编程中，接收多个参数的函数都可以转换为接收单个参数的函数，这个转换过程称为柯里化

 def add(x: Int, y: Int) = x + y

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