原创

Kotlin方法详解

方法是类或对象的行为特征的抽象,方法是类或对象最重要的组成部分。

一、方法与函数之间的关系

Kotlin的方法与函数其实是统一的,不仅定义函数和方法的语法相同,而且定义在类中的方法依然可独立出来。

fun main(args: Array<String>) {
    //将Dog的run方法赋值给rn变量
    //rn变量的类型应该是(Dog)->Unit
    var rn:(Dog)->Unit=Dog::run
    val d=Dog()
    rn(d)
    var et=Dog::eat
    et(d,"骨头")
}

class Dog {
    //定义一个无参数的run方法
    //其类型是()->Unit
    fun run() {
        println("run方法")
    }

    //定义一个带String参数的run方法
    //其类型是(String)->Unit
    fun eat(food: String) {
        println("喜欢吃:${food}")
    }
}

输出结果:

run方法
喜欢吃:骨头

二、中缀表示法

Kotlin的方法还可使用infix修饰,这样该方法就可通过中缀表示法调用。

infix方法只能有一个参数。

fun main(args: Array<String>) {
    var origin = Apple(3.4)
    //使用add方法
    val ap = origin add Apple(2.4)
    println(ap)
    origin drop Apple(1.4)
    println(origin)
}

class ApplePack(weight: Double) {
    var weight = weight
    override fun toString(): String {
        return "ApplePack[weight=${this.weight}]"
    }
}

class Apple(weight: Double) {
    var weight = weight
    override fun toString(): String {
        return "Apple[weight=${this.weight}]"
    }

    //定义中缀方法,使用infix修饰
    infix fun add(other: Apple): ApplePack {
        return ApplePack(this.weight + other.weight)
    }

    //定义中缀方法,使用infix修饰
    infix fun drop(other: Apple): Apple {
        this.weight -= other.weight
        return this
    }
}

输出结果:

ApplePack[weight=5.8]
Apple[weight=2.0]

三、componentN方法与解构

Kotlin允许将一个对象的N个属性“解构”给多个变量。

如果希望将对象解构给多个变量,必须为该对象的类定义componentN()方法。希望将对象解构给几个变量,就需要为该类定义几个componentN()方法,且该方法需要operator修饰。

fun main(args: Array<String>) {
    //创建User对象
    val user = User("刘备", "你不知道", 8000)
    var (name, pass: String) = user
    println(name)
    println(pass)

    var (name2, pass2, age) = user
    println(name2)
    println(pass2)
    println(age)
}

class User(name: String, pass: String, age: Int) {
    var name = name
    var pass = pass
    var age = age

    //定义operator修饰的componentN方法,用于结构
    operator fun component1(): String {
        return this.name
    }

    operator fun component2(): String {
        return this.pass
    }

    operator fun component3(): Int {
        return this.age
    }
}

输出结果:

刘备
你不知道
刘备
你不知道
8000

在某些收,程序希望结构对象后面几个componentN(0方法的返回值、忽略前面几个componentN()方法的返回值,此时可通过下划线(_)来占位。

fun main(args: Array<String>) {
    //创建User对象
    val user = User("刘备", "你不知道", 8000)

    //如果不想要前面的某个属性,用"_"代替它
    var (_, pass2, age) = user
    println(pass2)
    println(age)
}

输出结果:

你不知道
8000

四、数据类和返回多个值的函数

Kotlin本身并不支持定义返回多个值的函数或方法,但是通过对象解构,可以让Kotlin函数返回多个值(本质就是让Kotlin返回一个支持解构的对象)。

Kotlin提供了一种特殊的类:数据类。专门用于封装数据。

数据类除使用data修饰之外,还要满足如下要求:

  • 主构造器至少需要有一个参数。
  • 主构造器的所有参数需要用val或var声明为属性。
  • 数据类不能用abstract、open、sealed修饰,也不能定义成内部类。
  • 在Kotlin1.1之前,数据类只能实现接口;现在数据类也可继承其他类。

定义数据类之后,系统自动为数据类生成如下内容:

  • 生成equals()/hashCode()方法。
  • 自动重写toString()方法,返回形如“User(name=John,age=42)”的字符串。
  • 为每个属性自动生成operator修饰的componentN()方法。
  • 生成copy()方法,用于完成对象复制。
fun main(args: Array<String>) {
    //通过解构获取函数返回的两个值
    var (rt, status) = factorial(6)
    println(rt)
    println(status)
}

data class Result(val result: Int, val status: String)

fun factorial(n: Int): Result {
    if (n == 1) {
        return Result(1, "成功")
    } else if (n > 1) {
        return Result(factorial(n - 1).result * n, "成功")
    } else {
        return Result(-1, "参数必须大于0")
    }
}

输出结果:

720
成功

Kotlin标准库提供了Pair和Triple两个数据类。Pair数据类可包含两个任意类型的属性;Triple可包含三个任意类型的属性。

五、在Lambda表达式中解构

Kotlin允许对Lambda表达式使用解构,如果Lambda表达式的参数是支持解构的类型,就可以通过将它们放在括号中引入多个新参数来代替单个参数。

Lambda表达式包含两个参数和使用解构的区别:

{a-> ... }//一个参数
{a,b -> ... }//两个参数
{(a,b) -> ... } //一个解构对
{(a,b),c -> ... }//一个解构对和第三个参数

Lambda表达式的多参数是不需要使用圆括号的,Lambda表达式的形参列表中出现圆括号就是解构

学海无涯苦作舟

我的微信公众号.jpg

基本语法
  • 作者:HunterArley (联系作者)
  • 发表时间:2019-11-26 09:50
  • 版权声明:本网站部分内容转载于合作站点或其他站点,但都会注明作/译者和原出处。如有不妥之处,敬请指出。
  • 公众号转载:请在文末添加作者公众号二维码