函数声明
Kotlin 中的函数使用 fun 关键字声明：
fun a(): Int {
return 1
}
fun aa(x:Int,y:Int):Int{
return x*y
}
fun aaa(x:Int,y:Int)=x*y
fun b(): String {
return ""
}
fun c():Boolean{
return true
}
fun d(){
}
fun e():Unit{
}
fun aa(a:()-> Unit){
if (2>3){
a.invoke()
}else{
print("条件不满足 执行不了 \n")
}
}
aa {
print("条件满足了 执行 \n")
}
函数用法
调用函数使用传统的方法：
val result = double(2)
默认参数
函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量：
给第一个参数赋默认值，第二个参数， 调用给赋值(age=18)，也叫具名参数
fun main(array:Array<String>){
getName("李四",age = 12)
getName(age = 18)
}
fun getName(name:String = "张三",age:Int){
println("$name,$age")
}
打印：李四,12
张三,18
给最后参数赋默认值，可以简写
fun main(array:Array<String>){
getName(18)
}
fun getName(age:Int,name:String = "张三"){
println("$age,$name")
}
打印输出：18,张三
覆盖方法总是使用与基类型方法相同的默认参数值。 当覆盖一个带有默认参数值的方法时，必须从签名中省略默认参数值：
open class A {
open fun foo(i: Int = 10) { /*……*/ }
}
class B : A() {
override fun foo(i: Int) { /*……*/ } // 不能有默认值
}
如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用具名参数调用该函数来使用：
fun foo(
bar: Int = 0,
baz: Int,
) { /*……*/ }
foo(baz = 1) // 使用默认值 bar = 0
如果在默认参数之后的最后一个参数是 lambda 表达式，那么它既可以作为具名参数在括号内传入，也可以在括号外传入：
fun foo(
bar: Int = 0,
baz: Int = 1,
qux: () -> Unit,
) { /*……*/ }
foo(1) { println("hello") } // 使用默认值 baz = 1
foo(qux = { println("hello") }) // 使用两个默认值 bar = 0 与 baz = 1
foo { println("hello") } // 使用两个默认值 bar = 0 与 baz = 1
fun foo(
bar: Int = 0,
baz: Int = 1,
qux: (r: Int,z: Int) -> Unit,
) {
if (bar>baz){
qux.invoke(bar,baz)
}
}
ob.foo(2,1) { r, z ->
run {
print(r + z)
}
}
具名参数
fun reformat(
str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' ',
) {
/*……*/
}
// 当调用这个函数时，你不需要命名它的所有参数:
reformat(
'String!',
false,
upperCaseFirstLetter = false,
divideByCamelHumps = true,
'_'
)
// 你可以跳过所有带有默认值的参数:
reformat('This is a long String!')
// 您可以跳过一些带有默认值的参数。但是，在第一个跳过的参数之后，必须命名所有随后的参数:
reformat('This is a short String!', upperCaseFirstLetter = false, wordSeparator = '_')
// 你可以使用spread操作符传递一个变量数目的参数(vararg):
fun foo(vararg strings: String) {
for (s in strings){
print("s=$s \n")
}
}
foo(strings = *arrayOf("a", "b", "c"))
// 输出结果
a
b
c
对于 JVM 平台：在调用 Java 函数时不能使用具名参数语法，因为 Java 字节码并不总是保留函数参数的名称。
返回 Unit 的函数
如果一个函数不返回任何有用的值，它的返回类型是 Unit。Unit 是一种只有一个值——Unit 的类型。这个值不需要显式返回：
// Unit
fun printHello(name: String?): Unit {
if (name != null)
println("Hello $name")
else
println("Hi there!")
// `return Unit` 或者 `return` 是可选的
}
// `return Unit` 或者 `return` 是可选的
fun printHello(name: String?): Unit {
if (name != null) {
println("Hello $name")
return
} else {
println("Hi there!")
return Unit
}
}
Unit 返回类型声明也是可选的。上面的代码等同于：
fun printHello(name: String?) { …… }
单表达式函数
当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可：
fun double(x: Int, y: Int): Int {
return x * y
}
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 Array
result.add(t)
return result
}
允许将可变数量的参数传递给函数：
val list = asList(1, 2, 3)
在函数内部，类型 T 的 vararg 参数的可见方式是作为 T 数组，即上例中的 ts 变量具有类型 Array <out T>。
只有一个参数可以标注为 vararg。如果 vararg 参数不是列表中的最后一个参数， 可以使用具名参数语法传递其后的参数的值，或者，如果参数具有函数类型，则通过在括号外部传一个 lambda。
当我们调用 vararg-函数时，我们可以一个接一个地传参，例如 asList(1, 2, 3)，或者，如果我们已经有一个数组并希望将其内容传给该函数，我们使用伸展（spread）操作符（在数组前面加 *）：
// 创建一个数组
val a = arrayOf(1, 2, 3)
// 将数组 伸展 作为可变参数 传入函数里面处理 --> 返回一个list
val list = asList(-1, 0, *a, 4)
// --> 这个时候 list 里面的元数是 -1,0,1,2,3,4
可变参数 函数 调用
fun <T> asL(int: Int, vararg s: T, inn: Int): List<T> {
val result = ArrayList<T>()
for (t in s) // ts is an Array
result.add(t)
return result
}
val list2 = asL(int=0,"","","",*a,inn = 0)
中缀表示法
标有 infix 关键字的函数也可以使用中缀表示法（忽略该调用的点与圆括号）调用。中缀函数必须满足以下要求：
infix fun Int.shl(x: Int): Int { …… }
// 用中缀表示法调用该函数
1 shl 2
// 等同于这样
1.shl(2)
函数作用域
在 Kotlin 中函数可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 或 Scala 那样需要创建一个类来保存一个函数。此外除了顶层函数，Kotlin 中函数也可以声明在局部作用域、作为成员函数以及扩展函数。
局部函数
Kotlin 支持局部函数，即一个函数在另一个函数内部：
fun dfs(graph: Graph) {
fun dfs(current: Vertex, visited: MutableSet<Vertex>) {
if (!visited.add(current)) return
for (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)) return
for (v in current.neighbors)
dfs(v)
}
dfs(graph.vertices[0])
}
成员函数
成员函数是在类或对象内部定义的函数：
class Sample {
fun foo() { print("Foo") }
}
成员函数以点表示法调用：
Sample().foo() // 创建类 Sample 实例并调用 foo
泛型函数
函数可以有泛型参数，通过在函数名前使用尖括号指定：
fun <T> singletonList(item: T): List<T> { /*……*/ }
内联函数
内联函数在这里讲述。
扩展函数
扩展函数在其自有章节讲述。
高阶函数和 Lambda 表达式
高阶函数和 Lambda 表达式在其自有章节讲述。
