Kotlin函数
默认参数（default arguments）
示例代码
fun test(a: Int = 0, b: Int = 1) = println(a - b)
fun main(args: Array<String>) {
test()
test(2)
test(b = 2) //显示指定参数名
test(3, 2)
test(a = 3)
}
输出
-1
1
-2
1
2
对于重写的方法来说，子类所拥有的重写方法会使用与父类相同的默认参数值。
在重写一个拥有默认参数值的方法时，方法签名中必须要将默认参数值省略掉。
示例代码
open class A {
open fun method(a: Int, b: Int = 4) = a + b
}
class B : A() {
override fun method(a: Int, b: Int) = a + b
}
fun main(args: Array<String>) {
println(A().method(1))
println(B().method(2))
}
输出
5
6
如果一个默认参数位于其他无默认值的参数前面，那么默认值只能通过在调用函数时使用具名参数的方式来使用。
示例代码
fun test2(a: Int = 1, b: Int) = println(a - b)
fun main(args: Array<String>) {
test2(b = 3) // 具名参数（named argument）
}
输出
-2
如果函数的最后一个参数是lambda表示式，而且在调用是位于圆括号之外，
那么就可以不指定lambda表达式具名参数名。
示例代码
fun test3(a: Int = 1, b: Int = 2, compute: (x: Int, y: Int) -> Unit) {
compute(a, b)
}
fun main(args: Array<String>) {
test3(2, 3, ::test)
test3(2, 3, { a, b -> println(a - b) })
test3(2, 3) { a, b ->
println(a - b)
}
test3(2) { a, b ->
println(a - b)
}
test3 { a, b ->
println(a - b)
}
}
输出
-1
-1
-1
0
-1
具名参数，在调用函数时，函数参数可以是具名的。当一个函数有大量参数或是一些参数拥有默认值时，这种调用方式是比较方便的。
示例代码
fun test4(a: Int, b: Int = 2, c: Int = 3, d: Int) = println(a + b + c + d)
fun main(args: Array<String>) {
test4(1, 2, 3, 4)
test4(a = 1, b = 2, c = 3, d = 4)
test4(a = 1, d = 5)
}
输出
10
10
11
在调用函数时，如果同时使用了位置参数与具名参数，那么所有的位置参数都必须要位于第一个具名参数之前, 比如说，foo(1,x = 2)是允许的；不过foo(x = 1, 2)是不允许的。
对于重写的方法来说，子类所拥有的重写方法会使用与父类相同的默认参数值。在重写一个拥有默认参数值的方法时，方法签名中必须要将默认参数值省略掉。
示例代码
fun test4(vararg strings: String) {
println(strings.javaClass) // strings的java类型是数组类型
strings.forEach { println(it) }
}
fun main(args: Array<String>) {
test4("a", "b", "c")
//可变参数可以借助于spread operator以具名参数的形式传递
test4(strings = *arrayOf("a", "b", "c"))
test4(strings = "a")
val arrays = arrayOf("a", "b", "c")
test4(*arrays)
}
输出
class [Ljava.lang.String;
a
b
c
class [Ljava.lang.String;
a
b
c
class [Ljava.lang.String;
a
class [Ljava.lang.String;
a
b
c
在kotlin中调用Java方法时不能使用具名参数语法，因为Java字节码并不会总是会保留方法参数名信息。
单表达式函数，函数的返回类型如果可以通过类型推断判断出来，那么返回类型就可以省了掉。
示例代码
fun add(a:Int,b:Int):Int = a +b
无返回值示例
fun myPrint(name:String):Unit{
println(name)
return Unit
}
显示返回类型,拥有方法体的函数必须要显示指定返回类型，除非函数返回Unit，这时返回类型就可以省略掉. Kotlin并不会推断拥有块体的函数的返回类型，因为这种函数可能拥有非常复杂的控制流程，返回类型对于阅读代码的人来说就不是那么明显了（有时，对于编译器来说亦如此）
在一个方法中，只允许一个参数为vararg，通常作为最后一个参数。如果vararg不是最后一个参数，那么其后的参数就需要通过具名参数形式进行传递。如果其后的参数是函数类型，那么还可以通过在圆括号外传递lanbda表达式来实现。
示例代码
fun <T> conver2List(vararg elements: T): List<T> {
val result = ArrayList<T>()
elements.forEach { result.add(it) }
return result
}
fun main(args: Array<String>) {
println(conver2List("hello", "world", "hello world"))
var element = arrayOf("welcome", "bye", "test")
println(conver2List("zhangsan", "lisi", *element))
}
输出
[hello, world, hello world]
[zhangsan, lisi, welcome, bye, test]
中缀符号（infix notation) ，函数还可以通过中缀符号形式来调用，需要满足如下3个条件：
1.是成员函数或是扩展函数
2.拥有单个参数
3.声明时使用infix关键字
示例代码
class InfixTest(private var a: Int) {
infix fun add(b: Int) = this.a + b
}
fun main(args: Array<String>) {
val infixTest = InfixTest(2)
//以下两种方式等价
println(infixTest.add(5))
println(infixTest add 5) //中缀符号调用法
}
输出
7
7
内联函数（inline function）示例代码
inline fun myCalculate(a: Int, b: Int) = a + b
fun main(args: Array<String>) {
println(myCalculate(1, 2))
}
高级函数（high-order function）与lambda
Lambda表达式要求：
1.一个lambda表达式总是被一对花括号所包围。
2.其参数（如果有的话）位于 -> 之前（参数类型是可以省略掉的）
3.执行体位于 -> 之后
在Kotlin中，如果一个函数的最后一个参数是个函数，那么可以将lambda表达式作为实参传递进去，并且可以在调用时方法圆括号外去使用。
示例代码
val multiply: (Int, Int) -> Int = { a, b -> a * b }
val add: (Int, Int) -> Int = { a, b -> a + b }
val subtract = { a: Int, b: Int -> a - b }
val myAction = { println("hello world") }
val mayReturnNull: (Int, Int) -> Int? = { _, _ -> null }
val functionMaybeNull: ((Int, Int) -> Int)? = null
示例代码
package com.leofight.kotlin5
fun myCalculate(a: Int, b: Int, calculate: (Int, Int) -> Int): Int {
return calculate(a, b)
}
fun main(args: Array<String>) {
println(myCalculate(2, 3, { x, y -> x + y }))
println(myCalculate(2, 3, { x, y -> x - y }))
println(myCalculate(2, 3, { x, y -> x * y }))
println(myCalculate(2, 3) { x, y -> x + y })
}
输出
5
-1
6
5
示例代码
package com.leofight.kotlin5
fun String.filter(predicate: (Char) -> Boolean): String {
val sb = StringBuilder()
for (index in 0 until length) {
val element = get(index)
if (predicate(element)) {
sb.append(element)
}
}
return sb.toString()
}
fun main(args: Array<String>) {
var str = "hell7wor19"
println(str.filter { it.isLetter() })
}
输出
hellwor
示例代码
package com.leofight.kotlin5
fun main(args: Array<String>) {
val strings = arrayOf("hello", "world", "bye", "helloworlD", "welcome")
strings.filter { it.contains("h") }.forEach { println(it) }
println("---------")
strings.filter { it.length > 4 }.forEach { println(it) }
println("---------")
strings.filter { it.endsWith("d", true) }.map { it.toUpperCase() }.forEach { println(it) }
}
在默认情况下，lambda表达式中最后一个表达式值会隐式作为该lambda表达式的返回值，我们可以通过全限定的return语法来显式从lambda表达式返回值。
示例代码
fun main(args: Array<String>) {
val strings = arrayOf("hello","world","bye")
strings.filter {
val mayFilter = it.length > 3
mayFilter
}
strings.filter {
val mayFilter = it.length > 3
return@filter mayFilter
}
}
匿名函数示例代码
fun main(args: Array<String>) {
fun(x: Int, y: Int) = x + y
fun(x: Int, y: Int): Int {
return x + y
}
val strings = arrayOf("hello","world","bye")
strings.filter(fun(item):Boolean = item.length > 3).forEach(fun(item){ println(item)})
}
闭包示例代码
fun main(args: Array<String>) {
var sum = ""
val strings = arrayOf("hello","world","bye")
strings.filter { it.length > 3 }.forEach {
sum += it
}
println(sum)
}
带有接收者的函数字面值
Kotlin提供了这样一种功能：可以通过指定的接收者对象来调用一个函数字面值,在函数字面值内部，你可以调用接收者对象的方法而无需使用任何额外的修饰符
这一点非常类似于扩展函数。
示例代码
fun main(args: Array<String>) {
val subtract: Int.(other: Int) -> Int = { other -> this - other }
println(1.subtract(3))
println("-------------")
/*
匿名函数语法可以让我们指定函数字面值的接收者类型。这样，我们就可以先去声明一个带有接收者的函数类型变量，然后再去使用它
*/
val sum = fun Int.(other: Int): Int = this + other
println(1.sum(2))
println("-------------")
/*
带有接收者类型的函数的非字面值可以作为参数进行传递，前提是所需要接收函数的地方应该有一个接收者类型的参数，反之亦然。
比如说：类型 String.(Int) -> Boolean 与（String,Int) -> Boolean 等价
*/
val myEquals: String.(Int) -> Boolean = { param -> this.toIntOrNull() == param }
println("456".myEquals(456))
println("------------")
fun myTest(op: (String, Int) -> Boolean, a: String, b: Int, c: Boolean) = println(op(a, b) == c)
myTest(myEquals, "200", 200, true)
}
