四、Kotlin——方法

一、基础

// 普通方法 ，没有返回值
fun  sum1(a: Int, b: Int)  {

}
// 普通方法，带有返回值
fun sum2(a: Int,b: Int): Int{
    return  a + b
}

1、默认参数

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

fun  sum(a: Int = 10, b: Int) : Int{
    return  a + b
}

fun main() {
    val res = sum(b = 10)
    val res2 = sum(10,20)
    
}

2、如果参数有方法

fun  read(offset: Int = 0,start: Int,action:() -> Unit){
    // Unit是没有返回值的意思
    action()
}

fun main() {
    read(start = 10, action = {
        println("调用了")
    })
    //如果最后一个参数是方法，那么它既可以作为具名参数在括号内传，也可以在括号外传入。
    read(start = 5){
        println("调用了")
    }
}

3、可变数量的参数(Varargs)

方法的参数(通常是最后一个)可以用 vararg 修饰符标记:

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

fun main() {
    val  res = append('1','2','3','4')
    println(res)
}

当我们调用 vararg 方法时，我们可以一个接一个地传参，例如 append("h','e’,"",",o”)，或者，如果我们已经有一个数组并希望将其内容传给该方法，我们使用伸展(spread)操作符(在数组前面加*):

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

fun main() {
    val world = charArrayOf('w', 'o','r','l','d')
    val  res = append('1','2','3','4',*world)
    println(res)
}

可变参数的要求: 。只有一个参数可以标注为 vararg;。如果 vararg 参数不是最后一个参数， 可以使用具名参数语法，给后面的参数的传递值

二、在类中使用的情况

1、普通类的方法

class  Persion{
    // 对象方法，
    fun  run(){
        println("跑起来")
    }
}

fun main() {
    
 val p = Persion()
    p.run()
}

2、静态类的方法

如果我们想实现一个工具util的话，可以借助 关键字object来创建一个静态类

//静态类里面的方法 都是静态方法
//不需要构建实例对象，可以通过类名，直接访问静态方法
object SumTool{
    // 都是方法
    fun sum(a: Int,b: Int): Int{
        return  a + b
    }
}


fun main() {
    val  res = SumTool.sum(6,8)
    println(res)
}

3、companion object 伴生类的方法

Kotlin中并没有static关键字，我们需要借助companion object 来实现类静态方法的目的

class  Persion{
    // 对象方法，
    fun  run(){
        println("跑起来")
    }
    //不需要构建实例对象，可以通过类名，直接访问静态方法
    companion object{
        fun  run(){
            println("静态方法，跑起来")
        }
        fun  test(){
            println("测试方法")
        }
    }
}

fun main() {
    // 对象方法的调用
    val p = Persion()
    p.run()
    
    //静态方法的调用
    Persion.run()
    Persion.test()
}

三、在类中使用的情况

在Java 8的时候开始支持Lambda表达式，目前Lambda语法在Java中已经被广泛的运用，Lambda表达式可以理解为是一种语法糖，值得庆幸的是，Kotlin一经开源成熟就已经支持这种语法。

lambda表达式作为方法中的参数的时候。定义transform方法，可以对数组中的元素进行变换

val  numbers = arrayOf(1,2,3,4)
transform(numbers, action = {
    index,element -> index * element
})
println(numbers)

transform(numbers){
    inex,element -> inex * element
}
println(numbers)

如何使用it

• it并不是Kotlin中的一个关键字(保留字) 足
• it是在当一个高阶方法中Lambda表达式的参数只有一个的时候可以使用it来使用此参数
• it可表示为单个参数的隐式名称，是Kotlin语言约定的

var persions = arrayOf( Person(1), Person(2), Person(3))
 // 这里的it就表示每一个Person对象
 persions.forEach {
     //这里有个隐藏的it参数
     println(it.age)
 }

 //这里的it就表示每一个Int整数
 val numbers = arrayOf(1,3,5,7)
 numbers.forEach {
     //这里有个隐藏的it参数
     println(it)
 }

两个参数的

val numbers = arrayOf(1,3,5,7)
// 方式一
numbers.forEachIndexed(action = {index ,element ->
    println("index= $index element=$element")
})
// 方式二
numbers.forEachIndexed { index, element ->
    println("index= $index element=$element")
}