1. 声明

fun function(age: Int): Boolean {
    return age > 100
}

成员方法

class Person {
    fun test() {
        println("Kotlin")
    }
}

fun main() {
    Person().test()
}

静态方法

借助 object来创建一个静态类：

object UtilHelper {
    fun double(num: Int): Int {
        return num * 2
    }
}


fun main() {
    UtilHelper.double(2)
}

compantion object伴生类的方法

在普通类中创建静态方法，Kotlin中并没有static关键字，不过我们可以借助companion object来实现类方法的目的

lass Person {
    companion object {
        fun test2() {
            println("companion object 实现的类方法")
        }
    }
}
Person.test2()

2. 单表达式方法

当方法返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可：

fun double(x: Int): Int = x * 2

当返回值类型可由编译器推断时，显式声明返回类型是可选的：

fun double(x: Int) = x * 2

3. 传值参数

默认参数

方法参数可以有默认值，当省略相应的参数时使用默认值。与其Java相比，这可以减少重载数量：

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    /*……*/ 
}

我们可以通过类型后面的 = 来设置默认值。

如果重载的方法无具体默认值，怎么办呢，就要使用 具名参数了

具名参数

如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用具名参数调用该方法来使用：

fun foo(bar: Int = 0, baz: Int) {
    /*……*/ 
}

foo(baz = 1) // 使用默认值 bar = 0

如果在默认参数之后的最后一个参数是 lambda 表达式，那么它既可以作为具名参数在括号内传入，也可以在括号外传入：

如果参数类型是 () ，说明改参数是一个方法类型

• 方法参数的返回值使用 -> String，如果无法回使用—> Unit

fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) {
    /*……*/ 
}

// 
foo(1) { // 使用默认值 baz = 1
    println("hello") 
}

foo(qux = { // 使用两个默认值 bar = 0 与 baz = 1
    println("hello") 
}) 

foo { // 使用两个默认值 bar = 0 与 baz = 1
    println("hello") 
}        

实例参考

fun method(offset: Int = 0, start: Int, action: () -> String) {
    val ret = action
    println("$ret")
}

fun method(offset: Int = 0, start: Int) {
    println("method: $offset, $start")
}


fun main() {
    // ======================   在括号内传入 ======================
    method(1,2, action = {
        return@method "method"
    })

    // [简写]: 方法体最后一行，就是该方法的返回值
    method(1,2, action = {
        val result = 2 * 6
        "[括号内传入参数] > method $result"
    })

    // ======================= 在括号外传入 ========================

    method(start = 6) {
        "[括号外传入参数] > method"
    }

    // 具名参数
    method(start = 2)

    method(1,2)
}

4. 可变数量的参数-Varargs

传入的参数个数不确定

方法的参数（通常是最后一个）可以用 vararg 修饰符标记：

fun append(vararg str: Char): String {
    val result = StringBuffer()
    for (char in str) {
        result.append(char)
    }
    return result.toString()
}

允许将可变数量的参数传递给方法：

append('h', 'e', 'l', 'l', 'o')

可变参数的要求：

• 只有一个参数可以标注为 vararg；
• 如果 vararg 参数不是列表中的最后一个参数， 可以使用具名参数语法传递其后的参数的值，或者，如果参数具有方法类型，则通过在括号外部传一个 lambda。

当我们调用 vararg 方法时，我们可以一个接一个地传参，例如 append('h', 'e', 'l', 'l', 'o')，或者，如果我们已经有一个数组并希望将其内容传给该方法：

我们使用伸展**（spread）操作符（在数组前面加 *）**

val world = charArrayOf('w', 'o', 'r', 'l', 'd')
val result = append('h', 'e', 'l', 'l', 'o',' ', *world)

5. 方法作用域

在 Kotlin 中方法可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 那样需要创建一个类来保存一个方法。 此外除了顶层方法，Kotlin 中方法也可以声明在局部作用域、作为成员方法以及扩展方法。

局部方法

Kotlin 支持局部方法，即一个方法在另一个方法内部：

fun magic(): Int {
    fun foo(v: Int): Int {
        return v * v
    }

    val v1 = (0..100).random()
    return foo(v1)
}

局部方法可以访问外部方法（即闭包）的局部变量。