Kotlin开发-11-函数

本文学习 Kotlin 函数的相关用法。主要包括 :

函数的声明和使用,函数的参数和返回值,单表达式函数的使用,使用不定长参数。

局部函数,尾递归函数,高阶函数,内联函数等。

Lambda 表达式,匿名函数和闭包。

其他如,reifeid 关键字,非局部返回及带有接受者的函数字面值。

函数在 Kotlin 函数是一等公民,它的地位和对象一样,所以不要对函数特别看待,就把它当作对象看就行了,这样很多东西会好理解的多。

声明和使用

函数声明的一般形式为

1
2
3
fun functionName(param1:Type,param2:Type...)[:ReturnType]{
}

如果是 top-level 级别的函数可以直接使用函数名调用,如果是一个类函数,需要拿到类实例,使用点号标记法调用。

1
2
3
4
5
6
7
fun simpleFunction(param:String):Int{
return param.length
}
// 调用
simpleFunction("100")
Engineer().test()

Kotlin 支持中缀标记法调用函数,如果需要支持中缀标记法调用,需要满足条件:

是一个类函数或扩展函数,使用 infix 关键字声明,只有一个参数

1
2
3
4
5
6
7
8
9
10
infix fun Int.cross(another: Int): Int {
return this * another
}
class Engineer(var name: String = "", var age: Int = 0){
// together 函数
infix fun together(e: Engineer): Int {
return this.age + e.age
}
}

它使得函数可以像运算符那样使用

1
2
3
4
5
6
7
8
9
val x = 100
val result = x cross 10
// 相当于
val result2 = x.cross(10)
val e = Engineer()
var newEngineer = e together Engineer(name = "new")
// 相当于
var newEngineer2 = e.together(Engineer(name = "new"))

参数和返回值

Kotlin 中,参数使用 param:Type 的形式声明,每个参数必须声明数据类型;返回值在函数的最后,函数体之前,使用 :returnType 的形式声明,如果没有返回值,可以使用 :Unit 或者不写返回值的形式来表示。

参数支持 默认值 和 参数名指定参数 调用,简化函数的重载。主要体现在:

具有默认值的参数我们在调用过程中可以不传该参数,将会使用参数的默认值,另外我们可以使用参数名指定某些参数,也就是只传部分参数,当然没有默认值的参数是必须传的。

使用函数的默认值进行函数重载时,需要注意参数是从第一个参数开始往后面匹配的,因此无默认值的参数要往前面放,如下函数:

另外,由于如果最后一个参数是一个函数,那么可以将这个函数放在 () 之外,使用 Lambda 表达式传参,因此,如果有这样的函数参数,建议放在最后。

1
2
3
4
5
6
7
8
9
10
11
fun testDefParam(p1: String = "", p2: Int = 10, p3: Int = 1, p4: String) {
}
// 我们如此调用是不可以的
testDefParam("", "") // error
// 我们需要将无默认值的参数提到前面,才能自动匹配上
fun testDefParam(p4: String, p1: String = "", p2: Int = 10, p3: Int = 1) {
}

使用默认值调用时,当参数过多时,默认匹配的方式也多,而且我们必须将没有默认值的参数提前,会导致代码阅读性变差,不容易维护,因此相对更推荐使用参数名指定参数的方式,代码会更清晰,参数列表也没有任何限制,但是如果没有默认值的参数是必须传值的。

1
2
3
4
5
fun testNamedParam(p1: String = "", p2: Int = 10, p3: Int = 1,p4: String) {
}
// p4 参数是必须传的
testNamedParam(p2 = 11,p4 = "test")

类函数在继承时,子类不可以声明默认值,不论父类中同函数参数有没有默认值都不可以。

1
2
3
4
5
6
7
8
9
10
11
open class ATest {
open fun test(p1: Int, p2: String = "") {
}
}
class BTest : ATest() {
// p1 p2 参数都不能再声明默认值
override fun test(p1: Int, p2: String) {
super.test(p1, p2)
}
}

虽然在子类中我们不能声明参数默认值,但是父类中的参数默认值在子类中同样生效,如上面的代码我们可以如下调用:

1
2
ATest().test(1)
BTest().test(1)

函数的参数中的基本数据类型都是 val 类型的变量,也就是在函数体内无法改变其值

1
2
3
4
fun testFuncParamVal(index:Int,user:User){
index = 100 // error. val can not be reassigned
user.name = "" // error. val can not be reassigned
}

单表达式函数(Single-Expression)

单表达式函数 (Single-Expression function)

如果函数可以直接使用一条简单的表达式表示,可以省略函数体,直接在 = 之后声明,如果函数的返回类型可以通过类型推断得到,那么返回类型也可以省略。

1
2
3
fun singleExpressionFunc(): Int = 12 * 10
// 省略返回类型
fun singleExpressionFunc() = 12 * 10

不定长参数(varargs)

类似 java 中的 ...kotlin 使用 varargs 来表示不定长参数,varargs 声明的参数的类型实际上是一个 Array<out T> 类型的值,因此可以使用下标访问每一个参数

1
2
3
4
5
6
7
8
9
10
fun asList(vararg args: String): List<String> {
val list = ArrayList<String>()
for (arg in args) {
list.add(arg)
}
return list
}
// 简单调用
asList("1","@","3")

通常情况下 varargs 类型的参数应该是最后一个参数,因为由于 varargs 类型的参数接受的是一个数组,后面的参数将无法识别,不过好在 kotlin 有使用参数名指定参数的传参方法。

1
2
3
4
5
6
7
8
fun asList(vararg args: String,count:Int): List<String> {
val list = ArrayList<String>()
list += args
return list
}
// test
asList("1","@","3",count = 1)

当我们已经有一个数组时,希望将这个数组作为参数直接传递给函数,此时是无法传参的,因为它会将整个 Array 作为一项,如下面的代码中,会提示类型不对,这种情况可以使用 展开操作符(*),将数组展开

1
2
3
4
5
6
7
val strings = arrayOf("1", "2", "3")
// error. Required:String,Found:Array<String>
asList(strings,count = 1)
// 正确姿势
val strings = arrayOf("1", "2", "3")
asList(*strings,count = 1)

几种函数类型

顶级函数:函数可以声明为 top-level 级别,我们不需要单独定义一个类来容纳这个函数,顶级函数可以访问公开的类和属性。

局部函数:指的是声明在函数内部的函数,局部函数可以访问外部函数的局部变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// MainActivity 中的变量
val valueInMainActivity = 100
// 外部函数
fun localFunctionOutter(){
// 外部函数的局部变量
val valueInLocalFunctionOuter = 10
// 局部函数
fun localFunctionInner(){
// 局部函数的局部变量
val valueInLocalFunctionInner = 1
// 局部函数可以访问外部函数的局部变量
log("$valueInMainActivity $valueInLocalFunctionOuter $valueInLocalFunctionInner")
}
// 调用局部函数
localFunctionInner()
}

成员函数:声明在类和对象中的函数,它作为类的成员可以访问其他成员。

范型函数:函数中可以带有范型,关于范型的相关问题在 kotlin-范型 会有更细致的描述。

1
2
3
fun <T> test2(t:T) where T : Box<T>, T : Cloneable{
}

扩展函数:对已有类进行扩展,关于扩展函数的相关问题在 kotlin-扩展 会有更细致的描述。

1
2
3
4
5
fun <E> MutableList<E>.swap(index1: Int, index2: Int) {
val temp = this[index1]
this[index1] = this[index2]
this[index2] = temp
}

尾递归函数(tailrec)

我们在 Java 中使用递归函数时,如果递归的次数太多,具体能够承载的递归次数与函数的复杂程度有关,会导致堆栈溢出,kotlin 对递归函数做了优化,使用 tailrec 关键字声明尾递归函数,并且满足要求的形式,在编译时,会消除函数的递归调用,产生一段基于循环的代码,避免嵌套过深导致堆栈溢出。

要符合 tailrec 修饰符的要求,函数必须在它执行的所有操作的最后一步,递归调用它自身。如果在这个递归调用之后还存在其他代码,那么你不能使用尾递归,而且你不能将尾递归用在 try/catch/finally 结构内。

尾递归函数和我们平常的递归函数没有很大差别,使用 tailrec 关键字声明,参照官网上面的例子。

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

在编译时,他将会生成类似如下的结构

1
2
3
4
5
6
7
8
private fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = Math.cos(x)
if (x == y) return y
x = y
}
}

高阶函数

kotlin 中函数和属性一样可以作为另一个函数的参数或返回值,这类函数被称为高阶函数,它使得函数可以如同对象一样进行传递。

如同字符串类型是 String,整型的类型是 Int,函数具有自己的类型,函数的类型使用 (p1:Type1,p2:Type2...) -> returnType,其中参数的名称 p1,p2 是可以省略的,但是参数列表的 () 不能省略,需要注意的是即使函数返回值是 Unit 也无法省略,因为编译器将无法识别 (Type) 是一个什么类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 声明函数的类型
val fun1: (String, Int) -> Int = {
p1, p2 ->
p1.length + p2
}
// 带有参数名
val fun2: (p1: Int) -> Int = {
p1 ->
p1
}
// 返回值为 Unit
val fun3: (String) -> Unit = {}
// error. 不能省略 Unit
val fun4: (String) = {}

函数作为返回值

函数可以作为返回值,作为返回值时,需要使用 Lambda 表达式的方式书写。

1
2
3
4
5
6
7
8
9
10
11
12
// 函数作为返回值
fun testReturnFunction(): (String, Int) -> Int {
// 返回一个 参数为 (String,Int) 返回值为 Int 的函数
return {
p1: String, p2: Int ->
p1.length + p2
}
}
// 我们可以使用该函数获取内部返回的函数
val returnFunction = testReturnFunction()
var value = returnFunction("2", 1)

函数作为参数

函数可以作为函数参数,声明函数时可以像普通对象那样对待函数类型的参数

1
2
3
4
// 函数作为参数
fun testParamFunction(inFun: (String, Int) -> Int): Int {
return inFun("1", 1)
}

我们可以使用一个 Lambda 表达式创建一个函数作为参数,当函数 A 的最后一个参数也是函数时,可以在函数 A 后面直接用 {} 声明函数体。

1
2
3
4
5
6
7
8
// 普通用法
testParamFunction(inFun = {
s, i ->
s.length + i
})
// 简单用法
testParamFunction { s, i -> s.length + i }

如果该函数还有其他参数,那就必须使用 () 来放置这些参数,如下:

1
2
3
4
5
6
7
8
9
10
11
12
// 函数作为参数
fun testParamFunction(count:Int,inFun: (String, Int) -> Int): Int {
return inFun("1", 1)
}
// 普通用法
testParamFunction(1,inFun = {
s, i ->
s.length + i
})
// 简单用法
testParamFunction(1) { s, i -> s.length + i }

使用 :: 操作符,可以将一个定义好的参数作为参数传递,这边还涉及了一点反射的内容,暂时不去深究。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class FunParamTest() {
fun isYes(str: String): Int {
return str.length
}
fun test1(param:String) {
// 直接定义一个函数
val p1: (String) -> Int = { 100 }
test2(p1)
// 一个局部函数
fun isOdd(str: String): Int {
return str.length
}
// 用一个局部变量接受这个函数,并调用他
val p2 = ::isOdd
p2("")
// 直接传递该函数作为参数
test2(::isOdd)
// error,暂时不知道为什么,只有局部函数可以使用 :: 操作符传递
test2(::isYes)
}
fun test2(f: (String) -> Int) {
}
}

融会贯通,让函数如同对象一样自由的传递,我们以上面的两种函数为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 声明一个函数
val fun1: (String, Int) -> Int = {
p1, p2 ->
p1.length + p2
}
testParamFunction(1, inFun = fun1)
// 从另一个函数中返回一个函数
val fun5: (String, Int) -> Int = testReturnFunction()
testParamFunction(1, inFun = fun5)
// 使用 lambda 表达式创建一个函数
testParamFunction(1, inFun = {
p1, p2 ->
p1.length + p2
})
// 使用声明好的函数
fun fun6(p1:String,p2:Int):Int{
return p1.length + p2
}
testParamFunction(1, inFun = ::fun6)

Lambda 表达式

Kotlin 中使用 Lambda 表达式,Lambda 表达式使用如下方式。

1
2
3
4
{
param1,param2 ->
...函数体...
}

当某个参数我们不用时,可以使用 _ 代替,如函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fun testLambda(inFun: (String, Int) -> Int): Int {
return inFun("1", 1)
}
testLambda{
p1,p2 ->
p1.length + p2
}
// 不使用 p2 参数
testLambda{
p1, _ ->
p1.length
}

当只有一个参数时,如果没有用到这个参数可以直接不用声明,也可以使用单一参数的隐含名称 it 代替。

1
2
3
4
5
6
7
8
9
10
11
12
13
fun testLambda(inFun: (String) -> Int): Int {
return inFun("1")
}
// 当不使用参数时,可以不用声明
testLambda {
0
}
// 隐含参数 it
testLambda {
it.length
}

默认函数体的最后一条语句将会作为函数的返回值,但是不需要显式使用 return 关键字。如果想在其他位置返回值,需要使用带有后缀的 return 语句。

1
2
3
4
5
6
7
8
9
10
11
12
// 最后一句将作为返回值
testLambda {
it.length
}
// 使用带后缀的 return 语句返回指定值
testLambda {
if (it.length > 100)
return@testLambda it.length
else
return@testLambda 100
}

匿名函数

匿名函数与普通函数类似,但是不需要指定函数名,支持单单表达式函数,也支持多行函数。

匿名函数必须使用 () 传递,对 Lambda 表达式支持的一些使用方式,对匿名函数并不支持。

Lambda 表达式与匿名函数之间的另一个区别是,它们的 非局部返回(non-local return) 的行为不同。不使用标签的 return 语句总是从 fun 关键字定义的函数中返回。也就是说,Lambda 表达式内的 return 将会从包含这个 Lambda 表达式的函数中返回,而匿名函数内的 return 只会从匿名函数本身返回。

1
2
3
4
5
testParamFunction(1, inFun = (fun(p1, p2) = p1.length + p2))
testParamFunction(1, inFun = (fun(p1, p2): Int {
return p1.length + p2
}))

函数的闭包

Lambda 表达式和匿名函数可以访问外部变量,因此会形成闭包。

函数 和 函数能访问到的变量(环境) 的总和 就形成了一个闭包。也就是说,当一个内部函数访问了外部函数的变量,此时会形成一个闭包。

使用闭包的目的是隐藏一些变量,这些变量只在外部函数中声明,但是不需要声明为全局属性。

如下函数声明,在 MainActivity 中和外部函数中分别都有变量,内部函数访问这些变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// MainActivity 中的变量
val valueInMainActivity = 100
// 外部函数
fun localFunctionOuter(): () -> Unit {
// 外部函数的局部变量
val valueInLocalFunctionOuter = 10
// 局部函数
fun localFunctionInner() {
// 局部函数的局部变量
val valueInLocalFunctionInner = 1
// 局部函数可以访问外部函数的局部变量
log("valueInMainActivity = $valueInMainActivity " +
",valueInLocalFunctionOuter = $valueInLocalFunctionOuter " +
",valueInLocalFunctionInner = $valueInLocalFunctionInner")
}
// 调用局部函数
return ::localFunctionInner
}

在下面的调用中,虽然 localFunctionOuter() 函数已经结束了, 但是仍然可以使用返回的函数访问 localFunctionOuter() 内部的变量,我们对外部隐藏了 valueInLocalFunctionOuter 这个变量。

1
2
3
4
5
val f = localFunctionOuter()
f()
// 输出
MainActivity: valueInMainActivity = 100 ,valueInLocalFunctionOuter = 10 ,valueInLocalFunctionInner = 1

带有接受者的函数字面值

带有接受者的函数字面值(Function Literals with Receiver)

这是一个类似于扩展函数一样的特性,我们借助官网的几个例子理解一下他的用法。

1
2
val sum1 = fun Int.(other: Int): Int = this + other
1.sum1(2)

这种声明方式和普通的函数有相似之处,他只是在参数前面追加了 Int 类型,来表示这个函数是 Int 类型可以直接调用的。

用一个类似的例子看一下与普通函数的对比,我加了些空格来对比,普通函数不能访问 this 变量,也不能直接使用 Int 类型调用函数。

1
2
val sum1 = fun Int.(other: Int): Int = this + other
val sum2 = fun (other: Int): Int = other

对比一下,这种函数和扩展函数的差别,在使用和定义都没啥太大的差别,只是一个又函数名一个没有。

1
2
3
4
5
6
7
8
9
val sum1 = fun Int.(other: Int): Int = this + other
fun Int.sum3(other: Int): Int {
return this + other
}
1.sum1(2)
1.sum3(2)

再来看一下官网的另一个例子,第一眼看上去是有些懵逼的,分析一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 一个普通的类
class HTML {
// 一个普通的函数
fun body() {
}
}
// 还是一个普通的函数,返回值为 HTML 对象
// init 参数是一个无参无返回值的函数,
// 由于使用了 (HTML.) 说明这个函数是一个可以被 HTML 对象直接调用的函数
fun html(init: HTML.() -> Unit): HTML {
val html = HTML()
html.init() // 使用创建的 HTML 对象调用该函数
return html
}

调用,接受的参数是 HTML 类的一个无参无返回值的函数。

1
2
3
4
5
6
7
8
9
html {
body()
}
相当于
html({
body()
})

内联函数(inline)

使用高阶函数,每个函数都是一个对象,而且它还要捕获一个闭包,这些都会造成内存的损耗和运行效率的下降。使用内联函数可以将函数内联在函数调用处,而不用生成多余的对象再去调用他。

使用内联函数需要使用 inline 关键字声明,inline 关键字会影响函数本身,也会影响传递给他的表达式,这两者都会被内联到调用处。

1
2
3
inline fun testInline(str:String,f: (String) -> Int): Int {
return f(str)
}

如果函数有多个函数参数,可以使用 noinline 关键字声明那些不需要内联的函数

1
2
3
4
inline fun testInline(str: String, f1: (String) -> Int, noinline f2: () -> Unit): Int {
f2()
return f1(str)
}

内联函数不能作为递归参数使用,对于内联函数中没有声明为 noinline 函数参数(它们都是内联的),具有一些限制,这些参数 不能保存在域中,不能作为函数返回值返回,只能在内联函数内部调用,只能作为可以内联的函数参数传递给其他函数,我们通过一个例子说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 一个内联函数
inline fun testInline2(f1: (String) -> Int){
}
// 一个非内联函数
fun testInline3(f1: (String) -> Int){
}
inline fun testInline(str: String, f1: (String) -> Int, noinline f2: () -> Unit): (String) -> Int {
// error. inline 不可以保存在域内
// val localFun = f1
// error. 不能是递归的
// testInline(str,f1,f2)
// yes. 内联的 lambda 表达式参数,可以作为其他内联函数的参数
testInline2(f1)
// error. 内联的 lambda 表达式参数,不能作为非内联函数的参数
// testInline(f1)
// error. inline 不可以作为返回值
// return f1
}

非局部返回(Non-local return)

非局部返回(Non-local return)

Kotlin 中,使用不带标签的 return 语句只能返回使用 fun 关键字声明的函数,即普通的函数和匿名函数,在 Lambda 表达式是不允许使用不带标签的 return 语句的。

1
2
3
4
5
6
7
8
9
fun testNonReturn(f: (String) -> Int) {
log(f("test"))
log("testNonReturn")
}
testNonReturn {
// 不允许 return
it.length
}

我们可以使用带有指定标签的 return 语句,用来返回不同条件下的结果,因为 Lambda 表达式总是将最后一句的结果作为返回值,带有标签的 return 语句只会从对应 Lambda 表达式返回,后面代码仍会执行。

1
2
3
4
5
6
7
8
testNonReturn {
if (it.length > 2)
return@testNonReturn 100
else return@testNonReturn 1
}
MainActivity: 100
MainActivity: testNonReturn

对于内联函数,Lambda 表达式会被内联在调用处,那么可以使用 return 语句,此时 return 的作用是结束 Lambda 表达式作为参数的函数所在的那个函数,有点绕,借助下面的例子,testNonLocalReturn() 函数接受的 Lambda 参数将会结束 testNonLocalReturn() 函数所在的 foo() 函数,这种返回方式被称为 非局部返回(Non-local return);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
inline fun testNonReturn(f: (String) -> Int){
f("test")
}
fun foo():Boolean {
log("before testNonLocalReturn")
testNonLocalReturn {
// 返回值为 boolean,将直接退出 foo 函数
log("invoke testNonLocalReturn")
return true
}
log("after testNonLocalReturn")
return false
}

输出

1
2
MainActivity: before testNonLocalReturn
MainActivity: invoke testNonLocalReturn

有些时候 Lambda 表达式参数并不一定在函数内部执行,他可能通过一个局部对象或一个嵌套函数传递给其他执行环境调用,此时非局部返回也是被禁止的,为了明确这一点,我们使用 crossinline 关键字声明。

1
2
3
4
5
6
7
8
9
10
11
12
13
// 因为将会在另一个环境执行,使用 crossinline 标记
inline fun testNonLocalReturnV2(crossinline f: () -> Unit): Runnable {
val r = Runnable { f() }
return r
}
fun fooV2() {
testNonLocalReturnV2{
// error 使用 crossinline 标记,不能非局部返回
// return
}
log("invoke fooV2")
}

实体化的类型参数(reified)

实体化的类型参数(Reified type parameter)

主要用来解决范型参数无法像普通的类那样访问的问题。写一个函数,判断某个对象是不是属于某种类型。

1
2
3
4
5
6
fun <T> testReifiedType(p: Any, cls: Class<T>): Boolean {
return cls.isInstance(p)
}
// 我们可以这样使用它
testReifiedType("test", String::class.java)

这让我想起了 Gson 的使用方法,除了约定一个范型,我们还需要传递对应的 class 进去才能解析,kotlin 中内联函数支持 Reified type parameter,使用 reifeid 关键字注解范型,就可以像一个普通的类那样来访问范型类型了。

1
2
3
4
5
6
inline fun <reified T> testReifiedType(p: Any): Boolean {
return p is T
}
// 调用
testReifiedType<String>("")

需要注意的是,函数必须是 inline 类型才可以使用 reifeid 关键字注解。

------ 本文结束 🎉🎉 谢谢观看  ------