函数
Kotlin中，使用fun关键字定义一个函数，函数参数使用 Pascal 表示法定义，即 name: type。参数用逗号隔开。每个参数必须有显式类型。
fun foo(arg1:String,arg2:Boolean,arg3:Int):Int{
//do somethong
return 1
}当函数只有单个表达式时，可以省略花括号，直接写在=之后，如果返回值类型可由编译器推断出来，也可以省略返回值类型：
fun foo(arg1:String,arg2:Boolean,arg3:Int)=1//省略花括号和返回值类型后的函数形式具有块代码体的函数，必须显式指定返回值类型，除非返回值类型是Unit。编译器不会推断具有块代码体的函数的返回类型，因为这样的函数在代码体中可能有复杂的控制流，并且返回类型对于读者（又是甚至是编译器）是很不明显的。
fun foo(arg1:String,arg2:Boolean,arg3:Int):Int{
print("arg1="+arg1+"&arg2="+arg2+"arg3="+arg3)
return 0
}调用函数使用传统的方法
var value=foo()成员函数的调用要使用点表示法
R().foo()函数还可以使用中缀表示法来调用，当满足一下条件时：
infix fun Int.add(x:Int):Int{
return this+x
}
fun printAdd(){
val value=2 add 3//中缀表示法调用add函数
print("the value is $value")
}我们还可以在调用函数的时候使用命名的参数：
fun foo(arg1:String="Hello Kotlin",arg2:Boolean,arg3:Int){
print("arg1="+arg1+"&arg2="+arg2+"arg3="+arg3)
}
fun printFoo(){
foo(arg2 = true,arg3 = 7)//命名参数调用foo函数
}函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量。
fun foo3(arg1: String,arg2: Boolean=false,arg3: Int=0){//默认参数要放到函数参数的最后面
print("arg1="+arg1+"&arg2="+arg2+"arg3="+arg3)
}
fun printFoo3(){
foo3("Hello Kotlin")//调用时，可以不传入默认参数的值，这时默认参数就会使用默认值
}我们还可以为函数定义可变数量的参数，只要用vararg关键字修饰即可：
//可变数量的参数
fun foo4(vararg args:Int){
for (arg in args){
print(arg.toString()+",")
}
}
fun printFoo4(){
foo4(1,2,3,4,5)//1,2,3,4,5,
}如果我们已经有一个数组并希望将其内容传给该函数，我们使用伸展（spread）操作符（在数组前面加 *）：
//可变数量的参数
fun foo4(vararg args:Int){
for (arg in args){
print(arg.toString()+",")
}
}
fun printFoo4(){
val values= intArrayOf(1,2,3,4,5)
foo4(*values)//使用扩展运算符传一个数组给可变参数
}高阶函数
高阶函数可以将一个函数作为参数或返回值：
fun add2(x:Int=0,y:Int=0):Int{
return x+y
}
fun operate(x:Int=0,y:Int=0,body:(Int,Int)->Int){//body是一个函数类型，传入两个Int类型参数，返回一个Int类型参数
print("this result is "+body(x,y))
}
fun getValue(){
operate(3,7,::add2)
}Lambda表达式
以上的operate()方法，我们还有一个更简洁的调用方式，即传入一个lambda表达式：
fun getValue(){
operate(3,7,::add2)//函数参数传入一个函数
operate(3,7,{x,y->x+y})//函数参数传入一个lambda表达式
}Lambda 表达式的完整语法形式，即函数类型的字面值如下：
val sum = { x: Int, y: Int -> x + y }lambda 表达式总是被大括号括着， 完整语法形式的参数声明放在括号内，并有可选的类型标注， 函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个）表达式会视为返回值。
如果我们把所有可选标注都留下，看起来如下：
val sum: (Int, Int) -> Int = { x, y -> x + y }当函数参数是最后函数的最后一个参数，并且你传入一个lambda表达式作为相应的参数，则可以在圆括号之外指定它：
fun getValue(){
operate(3,7,::add2)//函数参数传入一个函数
operate(3,7,{x,y->x+y})//函数参数传入一个lambda表达式
operate(3,7){//函数参数作为函数的最后一个参数，并且传入的是一个lambda表达式，可以在在圆括号外指定
x,y->x+y
}
}如果lambda表达式只有一个参数，kotlin可以自己计算出签名，它允许我们不声明唯一的参数，并且隐含的为我们声明其名称为it：
fun upCase(str:String,body:(String)->String):String{//body是一个函数参数，传入一个String类型参数，返回一个String类型
return body(str)
}
fun transform(){
upCase("HelloKotlin"){//函数字面值只有一个参数，可以省略参数声明，其名称是it
it.toUpperCase()
}
}如果lambda表达式是调用的唯一参数，则调用中的圆括号可以完全省略：
fun String.upper(body:(String)->String):String{
return body(this)
}
fun transform(){
"HelloKotlin".upper { it.toUpperCase() }//lambda是调用的唯一参数，则调用的圆括号可以省略
}匿名函数
匿名函数与常规函数一样，只是省略了函数名称而已：
fun String.upper(body:(String)->String):String{
return body(this)
}
fun transform(){
"HelloKotlin".upper { it.toUpperCase() }//lambda表达式是调用的唯一参数，则调用的圆括号可以省略
"HelloKotlin".upper(fun(str:String):String{//将匿名函数作为一个函数参数传入
return str.toUpperCase()
})
}Lambda表达式和匿名函数之间的另一个区别是非局部返回的行为。一个不带标签的 return 语句总是在用 fun 关键字声明的函数中返回。这意味着 lambda 表达式中的 return 将从包含它的函数返回，而匿名函数中的 return 将从匿名函数自身返回。
fun foo() {
ints.forEach {
if (it == 0) return//这个 return 表达式从最直接包围它的函数即 foo 中返回。
print(it)
}
}值得注意的是：这种非局部的返回只支持传给内联函数的 lambda 表达式。 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。
fun transform():String{
"HelloKotlin".upper {
print(it.toUpperCase())
return@upper it.toUpperCase()//返回必须加标签限制
}
"HelloKotlin".upper(fun(str:String):String{
return str.toUpperCase()//从匿名函数返回
})
}带接收者的函数字面值
Kotlin提供了指定的接收者调用函数字面值的功能。在函数字面值的函数体中，可以调用该接收者对象上的方法而无需任何额外的限定符。
这样的函数字面值的类型是一个带有接收者的函数类型：
sum : Int.(other: Int) -> Int该函数字面值可以这样调用，就像它是接收者对象上的一个方法一样：
1.sum(2)匿名函数语法允许你直接指定函数字面值的接收者类型。 如果你需要使用带接收者的函数类型声明一个变量，并在之后使用它，这将非常有用。
val sum = fun Int.(other: Int): Int = this + other