前言

我们在开发中把复杂的逻辑拆分成多个功能函数，增加代码的可读性和可维护性。

函数声明

用关键字fun声明一个函数

fun sum(left:Int,right:Int):Int {
    return left+right
}

函数参数默认值

kotlin中函数允许有默认值，可以减少方法的重载(方法名相同，方法的参数类型和个数不同)

fun sum(left:Int,center:Int,right:Int = 0):Int {
    return left+center+right
}
// 我们可以选择性的对有默认值的函数传或者不传这个参数
fun main(){
    sum(0,10)
    sum(0,10,15)
}

可以减少Java语言中的方法重载

具名函数

调用一个众多参数的函数时，参数类型和参数名匹配比较麻烦，具名参数不用考虑参数在函数中的顺序a

fun main(){
    a(right = flase, center = "center", left = 0,isEmpty = false)
}
fun a(left :Int,center :String,right:Boolean isEmpty:Boolean)

函数拥有4个参数，可以解决复杂的函数很多参数赋值问题

函数默认返回值Unit

"无返回值"的函数，它返回值类型是Unit。通常我们会省略它

fun a(p1:Int):Unit{return Unit}
// 省略Unit
fun a(p1:Int){return}

可以直接return 或者加上Unit

单函数表达式

if或者when分支块仅有一行时，可以省略花括号。当函数返回单个表达式，可以省略花括号并且在=符号后指定代码

fun sum(left:Int,right:Int):Int = left+right
// kotlin编译器可以推断出函数的返回值类型，可省略函数的返回值类型
fun sum(left:Int,right:Int) = left+right
// 函数=表达式
fun isEmpty(str:String) = if(str.length == 0) true else false
fun findNum(num:Int) = when(num){
    1->0
    2->1
    else -> -1
}

可变数量的参数

java中用propertyType... propertyName声明一个可变数量的参数：

private void s(Integer... a){...}

kotlin中使用关键字vararg声明可变数量的参数，一个方法只能有一个参数用vararg修饰。

fun main(){
    sum(1,2,3)
}
fun sum(vararg a:Int){
    for(i in a){
        println(i)
    }
}

如果vararg参数不是最后一个参数，其后的参数可用具名参数的方式传递：

fun main(){
    sum(1,2,3,b=10,c=100)
}
private fun sum(vararg value:Int,b:Int,c:Int){...}

通过数组给vararg类型参数传参，使用伸展(spread)操作符(在数组前面加*）:

fun main(){
    val a = intArrayOf(1,3,4)
    sum(*a,b=3,c=4)
}
fun sum(vararg a:Int,b:Int,c:Int){...}

中缀表示法

使用infix关键字修饰的函数可以使用中缀表示法，忽略函数调用的点和括号。必须满足的条件：

用infix修饰的函数只有一个参数
必须是成员函数或扩展函数
不能是vararg声明的可变数量的参数 Kotlin中提供的Tuples.kt中数据类型Pair

public data class Pair<out A, out B>(
    public val first: A,
    public val second: B
) : Serializable {...}

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

数据类型Pair有infix修饰的扩展函数to->A.to(that:B)

fun test() {
    val pair = 20 to "age"
    println("pair=$pair") // pair=(20, age)
}

使用A to B的方式创建了Pair对象，省略了调用函数的点和括号。

// 用`infix`
infix fun <T> Collection<T>.has(item:T) = item in this

fun test() {
    val arr = arrayListOf("kotlin","ios","android")
    if (arr has "android"){
        println("has android")
    }else{
        println("no android")
    }
}

函数作用域

Kotlin中函数可以在文件顶层声明，默认情况下可以在当前文件所有的项目中任意地方访问，除非在函数显示的加上private访问修饰符。

// 当前项目中可以调用
fun sum(left:Int,right:Int): Int{...}
// 当前文件中可以调用
private fun a(){}

成员函数

类内部或对象内部创建的函数我们称成员函数：

class A{
    fun b(){}
}
fun main(){
    A().b()
}

局部函数(Kotlin中支持一个函数嵌套另一个函数)

局部函数：函数内部声明一个函数。

fun main(){
    val a=1
    fun b(){
        println(a)
    }
}

局部函数可以访问外部函数声明的属性。

泛型函数

用关键字fun之后根<T>声明一个泛型函数

fun <T> a(b:T){
    println(b)
}

可以声明的泛型类型作为函数的返回值

fun <T> a(b:T):T{
    return b
}

总结

Kotlin函数和Java中的方法不论写法还是使用都是有很大区分的。kotlin更加简单化，更人性化。

Kotlin基础三：函数

前言