函数声明

在Kotlin中，声明函数使用fun关键字

fun test(x:Int):Int{return 2*x
}

函数应用

传统方式调用函数

val result=test(2)

使用点表示法调用函数

MK().test()//创建MK实例并调用test函数

中缀表示法(Infix notation)

当遇到以下情况的时候，函数也可以使用中缀表示法：
- 当函数是成员函数或拓展函数的时候
- 当函数只有一个参数的时候
- 当被infix关键字修饰的时候

// 定义了拓展函数
infix fun Int.shl(x: Int): Int {
...
}//使用中缀表示法使用函数
1 shl 2// 以上等价于
1.shl(2)

参数

函数的参数定义使用Pascal表示法，例如：name:type,参数需要用逗号分隔开，每个参数的类型都必须显示输入.

fun powerOf(number: Int, exponent: Int) {...
}

参数默认值

函数的参数可以有默认值，当省略相关值的时候，就会应用默认值，与其他语言相比，这允许减少重载的数量.

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size()) {
...
}

定义参数的默认值只需要直接在参数类型后加等号(=)后直接跟上就好

作为基本用法，重写方法的时候经常会用到参数默认值，当重写一个有默认参数值方法的时候，必须省略默认参数值：

open class A {open fun foo(i: Int = 10) { ... }
}class B : A() {override fun foo(i: Int) { ... }  // 不允许有默认值
}

参数名应用

在调用函数的时候函数参数可以携带名字，当函数有很多参数或只有一个有默认参数的时候，这个用法就很方便。例如有这个函数：

fun reformat(str: String,normalizeCase: Boolean = true,upperCaseFirstLetter: Boolean = true,divideByCamelHumps: Boolean = false,wordSeparator: Char = ' ') {
...
}

我们调用的时候可以这样：

reformat(str)

然而我们调用函数没有使用默认值的时候，却是这样：

reformat(str, true, true, false, '_')

如果参数携带参数名，那代码可读性将很好,例如下面这样:

reformat(str,normalizeCase = true,upperCaseFirstLetter = true,divideByCamelHumps = false,wordSeparator = '_'
)

当我们不需要太多参数的时候，我们可以这样：

reformat(str, wordSeparator = '_')

==需要注意的是像这样携带参数名的语法不能在Java中使用，因为Java的字节码并没有保存函数的参数名==

Unit-函数返回类型

如果一个函数不需要返回任何有用的值，那么它的返回值类型可以为Unit，Unit类型只有一个值Unit,这个值的意思是不需要明确返回值

fun printHello(name: String?): Unit {if (name != null)println("Hello ${name}")elseprintln("Hi there!")// 可选使用`return Unit` 或者 `return`返回
}

Unit返回类型是可选的，以上代码等价于下面这样：

fun printHello(name: String?) {...
}

单一函数表达式

当函数只返回单一表达式的时候，可以折叠大括号直接在等号(=)后面添加表达式

fun double(x:Int):Int = x*2

如果返回值类型是可推断的，那么返回值类型也是可以省略

fun double(x:Int) = x*2

明确指定返回类型

在函数体中，除了返回Unit类型可以省略之外，其他类型都是需要明确指点，Kotlin不能根据代码块来推断返回值类型，因为函数中可能有复杂的流程控制，并且返回值类型对读者来说可能不明确(有时候对编译器也不明确)

可变参数(Varargs)

函数的参数可以被vararg关键字修饰(一般是最后一个参数)

fun <T> asList(vararg ts: T): List<T> {val result = ArrayList<T>()for (t in ts) // ts is an Arrayresult.add(t)return result
}

那么使用的时候可能是这样：

val list = asList(1, 2, 3)

在函数内被vararg修饰的T参数是一个数组，前面那个例子中ts等价于Array.

在一个函数中，只能允许一个参数被vararg修饰，如果被vararg修饰的参数不是参数列表中最后一个，那么应用的时候就需要携带参数名，如果参数有函数类型，那么就可以用lambda语法

当我们调用有vararg修饰参数的函数时，我们传递参数可以一个跟一个，如asList(1,2,3,4),或者如果我们已经有一个数组，并且我们想把这个数组的内容传递给函数，那么我们可以用拓展操作符(数组的前缀用*):

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

函数范围

在Kotlin中可以在文件的顶级结构下声明函数，意思就是说你可以不需要创建一个类来保存函数.像Java,C#,Scala语言一样，Kotlin中的函数也可以声明为局部函数，成员函数和拓展函数。

局部函数

Kotlin支持局部函数，例如把一个函数内嵌到另一个函数中：

fun dfs(graph: Graph) {fun dfs(current: Vertex, visited: Set<Vertex>) {if (!visited.add(current)) returnfor (v in current.neighbors)dfs(v, visited)}dfs(graph.vertices[0], HashSet())
}

局部函数也可以访问外部函数的局部变量，因此在上面的这个例子中，visited可以改成局部变量

fun dfs(graph: Graph) {val visited = HashSet<Vertex>()fun dfs(current: Vertex) {if (!visited.add(current)) returnfor (v in current.neighbors)dfs(v)}dfs(graph.vertices[0])
}

成员函数

成员函数可以定义在类中或对象中。

class Sample{fun foo(){println("foo");}
}

成员函数可以通过点号来调用

Sample().foo() //创建Sample实例然后再调用foo函数

泛型函数

函数也可以在函数名前面通过尖括号定义一个泛型参数

fun <T> singletonList(item :T) :List<T>{...
}

更多相关泛型知识，请查看泛型一章

尾递归函数

Kotlin支持一种函数式编程叫尾递归函数，这种方式可以允许算法使用递归来替换循环，这个还没有堆栈溢出的风险。当一个函数被标识为 tailrec并符合要求，编译器就可以优化递归，就是留下快速而有效的循环.

tailrec fun findFixPoint(x: Double = 1.0): Double= if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))

这个代码用来计算余弦的不动点，这是一个数学常数，可以很简便的从1.0开始重复调用Math.cos，直到结果不再变化就可以，上面的这个例子等价于下面这个例子：

private fun findFixPoint(): Double {var x = 1.0while (true) {val y = Math.cos(x)if (x == y) return yx = y}
}

要符合被tailrec修饰的资格，函数必须调用本身直到最后操作完成,如果在递归调用之后还有更多的代码，那么就不能使用尾递归，并且还不能在try/catch/finally模块中使用.目前尾递归仅在JVM后端支持。