函数声明（Function Declarations）
在Kotlin中，函数的声明使用fun关键字：
fun double(x: Int): Int {
}
函数用法（Function Usage）
使用传统的方法调用函数：
val result = double(2)
使用.操作符调用成员函数：
Simple().foo() //创建累的实例并调用foo（）方法
中缀符号（Infix notation）
当满足下列条件的时候，函数还可以使用中缀符号调用：
- 当函数是成员函数或者扩展函数的时候
- 当他们仅有一个参数的时候
- 当他们通过
infix关键字标记的时候
如：
// 为Int定义扩展函数
infix fun Int.shl(x:Int):Int{
...
}
//使用中缀符号调用扩展函数
1 shl 2
//等同于
1.shl(2)
参数（Parameters）
函数参数使用Pascal表示法定义，也就是名字：类型。参数之间使用逗号表示。每一个参数都必须显式指明类型。
fun powerOf(number:Int,exponent:Int){
...
}
默认参数（Default Arguments）
函数的参数可以拥有默认值，当省略相应的参数时使用默认值。同其他语言相比，这将减少重载方法的数量：
fun read(b:Array,off:Int = 0,len:Int = b.size()){
...
}
在类型之后，使用=定义参数的默认值。
重载的方法将总是使用与基本方法相同的默认值。当重载方法使用默认值的时候，默认参数值需要在方法签名中省去：
open class A {
open fun foo(i: Int = 10) { ... }
}
class B : A() {
override fun foo(i: Int) { ... } // no default value allowed
}
参数指定（Named Arguments）
当调用函数的时候，函数参数可以被命名。当一个函数有非常多的参数且一部分具有默认值的时候，这非常方便。
给定如下函数：
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-returning functions）
如果一个函数不需要返回任何有用的类型的值，则其可以返回Unit类型。Unit是只有一个Unit值的类型。该值不需要显式返回任何值：
fun printHello(name: String?): Unit {
if (name != null)
println("Hello ${name}")
else
println("Hi there!")
// `return Unit` or `return` is optional
}
Unit类型的返回声明是可选的。上述代码等同于：
fun printHello(name: String?) {
...
}
单表达式函数（Single-Expression functions）
当一个函数仅返回一个表达式，则可以省略花括号，函数体可以直接跟在=号后面：
fun double(x: Int): Int = x * 2
若编译器可以推断出返回值类型，则返回值类型是可以省略的：
fun double(x: Int) = x * 2
显式返回值类型（Explicit return types）
函数体是代码块的函数必须显式指定返回值类型，除非返回值类型是Unit，则是可以省略的。Kotlin不能推断函数体是代码块的函数的返回值类型，因为这样的函数在代码块中可能有复杂的流程控制，返回值类型对于读者而言可能不是明确的（有时甚至于对编译器而言）
可变数量的参数（Variable number of arguments Varargs）
函数的参数（通常是最后一个）可以使用vararg修饰符修饰：
fun asList(vararg ts: T): List {
val result = ArrayList()
for (t in ts) // ts is an Array
result.add(t)
return result
}
允许可变数量的参数传入该函数：
val list = asList(1, 2, 3)
在函数中，类型T的vararg参数被作为T类型的数组，即上面示例中的ts变量具有类型Array 。
在参数列表中，只有一个参数能被vararg修饰符标记。如果vararg参数不是参数列表中的最后一个，则可以使用指定参数名语法来传入vararg参数之后的参数，如果参数具有函数类型，则可以在括号外边传入λ表达式。
当我们调用一个vararg函数的时候，我们可以一个接一个的传参，如asList(1,2,3),如果我们已经有一个数组，并想将其作为参数传入函数，我们可以使用*操作符将数组传入其中：
val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)
函数作用域（Function Scope）
在Kotlin中，函数可以在文件的顶层级声明，意味着如果你不必创建一个类只为持有一个函数，像Java，C#或Scala。除了顶级函数之外，Kotlin函数也可以被声明为局部函数，成员函数或扩展函数。
局部函数（Local Functions）
Kotlin支持局部函数，也就是说，在一个函数的内部再定义一个函数：
fun dfs(graph: Graph) {
fun dfs(current: Vertex, visited: Set) {
if (!visited.add(current)) return
for (v in current.neighbors)
dfs(v, visited)
}
dfs(graph.vertices[0], HashSet())
}
局部函数可以访问外部函数（闭包1和闭包2）的局部变量，因此在上例中，visited可以是局部变量。
fun dfs(graph: Graph) {
val visited = HashSet()
fun dfs(current: Vertex) {
if (!visited.add(current)) return
for (v in current.neighbors)
dfs(v)
}
dfs(graph.vertices[0])
}
成员函数（Member Fuctions）
一个成员函数是定义在类或对象内部的函数：
class Sample() {
fun foo() { print("Foo") }
}
成员函数可以通过.符号调用：
Sample().foo() // creates instance of class Sample and calls foo
更多关于类和成员重写的知识参见类和继承。
泛型函数（Generic Functions）
函数可以使用泛型参数，泛型参数在函数名之前使用尖括号指定：
fun singletonList(item: T): List {
// ...
}
内联函数（Inline Functions）
内联函数参见这里
扩展函数
扩展函数参见这里
高阶函数和λ表达式（Higher-Order Functions and Lambads）
高阶函数和λ表达式参见他们的模块。
尾递归函数（Tail recursive functions）
Kotlin 支持一种称为尾递归的函数式编程风格。 这允许一些通常用循环写的算法改用递归函数来写，而无堆栈溢出的风险。 当一个函数用 tailrec 修饰符标记并满足所需的形式时，编译器会优化该递归，留下一个快速而高效的基于循环的版本。
tailrec fun findFixPoint(x: Double = 1.0): Double
= if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))
这段代码计算余弦的不动点（fixpoint of cosine），这是一个数学常数。 它只是重复地从 1.0 开始调用 Math.cos，直到结果不再改变，产生0.7390851332151607的结果。最终代码相当于这种更传统风格的代码：
private fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = Math.cos(x)
if (x == y) return y
x = y
}
}
要符合 tailrec 修饰符的条件的话，函数必须将其自身调用作为它执行的最后一个操作。在递归调用后有更多代码时，不能使用尾递归，并且不能用在 try/catch/finally 块中。目前尾部递归只在 JVM 后端中支持。