Kotlin 笔记 3.7:方法

之前的例子中,我们使用 fun 关键字来定义一个方法,现在来进一步学习一下 Kotlin 中的方法:

方法声明

使用 fun 关键字:

fun say(word:String){
    println(wrod)
}

fun sum(x:Int,y:Int):Int{
    return x+y
}

方法使用

在 Kotlin 中,方法是可以单独声明的,所以对于单独声明的方法,直接调用即可:

say("你好")
var number = sum(13,20)

对于声明在类中的方法,和 Java 一样,需要使用对象去调用:

Person("张三").say("你好")
var number = Person("张三").sum(10,28)

默认参数

Kotlin 的方法参数可以有默认值,当省略相应的参数时使用默认值。

fun main() {
    println(sum(10))
}


fun sum(x: Int, y: Int = 10): Int {
    return x + y
}
//输出结果:20

当方法有多个参数,并且有默认值的参数在没有默认值的参数前面的时候,在调用的时候,需要显式指定:

fun main() {
    println(sum(y = 10))
}


fun sum(x: Int = 10, y: Int): Int {
    return x + y
}
//输出结果:20

当我们的方法有很多个参数的时候,在调用的时候会很难搞清楚究竟哪个值对应的是哪个参数,然而 Kotlin 也可以这样写:

fun main() {
    println(sum(a = 10, b = 20, c = 30, d = 40, e = 50, f = 60))
}


fun sum(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int): Int {
    return a + b + c + d + e + f
}

在调用的时候也可以加变量名,是不是清晰了很多?

无返回类型

类似于 Java 当中的 void,在 Kotlin 中使用 Unit 关键字。和 Java 不同的是,这个 Unit可以省略:

fun setName(name:String):Unit{
    ...
}
//等效于
fun setName(name:String){
    ...
}

表达式方法

当方法返回单个表达式的时候,可以将大括号省略,直接 = 返回表达式

fun sum(a:Int,b:Int):Int{
    return a+b
}
//等效于
fun sum(a:Int,b:Int):Int = a+b

参数可变方法

Java 中使用 ... 来标识方法的参数数量不确定,在 Kotlin 中使用 vararg 关键字:

fun main() {
    println(sum(11, 22, 333))
}

fun sum(vararg a: Int): Int {
    var number = 0
    for (i in a) {
        number += i
    }
    return number
}
//结果:366

作用域

Kotlin 中,方法不需要像 Java 一样必须包含在类体呢,在 Kotlin 中可以直接声明一个单独的方法,称之为 顶层方法

局部方法

一个方法在另一个方法内部,称之为 局部方法

fun main() {
    println(outer(10))
}


fun sum(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int): Int {
    return a + b + c + d + e + f
}

fun outer(a: Int): Int {
    var a: Int = a

    fun inner(a: Int, b: Int): Int {
        return a + b
    }

    return inner(a, 10) //调用局部方法
}
//输出 20

成员方法

就是普通的、定义在类内的方法,通过 对象.方法名 的方式调用。

扩展函数

之前讲类的时候,讲过扩展函数:

fun main() {
    var test = Test()
    println(test.newMethon(10, 20))
}

class Test {
    fun methon(a: Int, b: Int): Int {
        return a + b
    }
}

fun Test.newMethon(a: Int, b: Int): Int {
    return a + b
}
//执行结果:30