Kotlin运算符重载及其他约定

最新推荐文章于 2022-10-16 11:55:15 发布

居家小男

最新推荐文章于 2022-10-16 11:55:15 发布

阅读量363

点赞数

分类专栏：移动开发笔记文章标签： java android kotlin

本文链接：https://blog.csdn.net/dhbdbsbsn/article/details/108759896

版权

移动开发笔记专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Kotlin运算符重载及其他约定

前言：内容主要包括运算符重载、约定（支持各种运算的特殊命名函数）、委托属性，结合代码，让重载运算符相关知识简单易懂。

4.在for循环中使用iterator约定

五、解构声明和组件函数

一、概述

在Kotlin中有很多类似于Java的特性，其中之一就是调用自己代码中定义的函数，来实现特定的语言结构。但是区别于Java，在Kotlin中，这些功能与特定的函数名相关。例如，在类中定义了一个plus函数，那么按照约定，就可以在该类的实例上使用+号来调用这个函数。在Kotlin中，我们把这种技术称为约定。

作为例子，我们实现一个Point类，来表示一个点，后面的例子基于此类：

data class Point(val x:Int,val y:Int)

二、重载算数运算符

在Kotlin中使用约定最直接的例子就是算数运算符。

1.重载二元算数运算

我们要支持的第一个运算就是把两个点加到一起。这个运算需要把点的（X,Y）坐标分别加到一起。

定义一个plus运算符：

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){
    operator fun plus(other: Point):Point{
        return Point(x+other.x,y+other.y)
    }
}

fun main(args: Array<String>) {
    val p1 = Point(10,20)
    val p2 = Point(30,40);
    //会调用Point对象的plus方法
    println(p1+p2)
}

运行结果：

注意：如何使用operator 关键字来声明plus函数。对于重载运算符的所有函数都需要用该关键字来标记，表示你打算把这个函数作为相应的约定实现，而不是单纯地定义一个同名函数。实际上p1+p2==p1.plus(p2)

还可以把运算符定义为扩展函数：

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){}
//定义为扩展函数
operator fun Point.plus(other: Point):Point{
    return Point(x+other.x,y+other.y)
}

fun main(args: Array<String>) {
    val p1 = Point(10,20)
    val p2 = Point(30,40);
    //会调用Point对象的plus方法
    println(p1+p2)
}

下面列举二元运算符及其对应的函数名：

表达式	函数名
a*b	times
a/b	div
a%b	mod
a+b	plus
a-b	minus

定义一个运算数类型不同的运算符：

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){}
//定义为扩展函数
operator fun Point.times(scale:Double):Point{
    return Point((this.x*scale).toInt(),(this.y*scale).toInt())
}

fun main(args: Array<String>) {
    val p1 = Point(10,20)
    println(p1*0.5)
}

运行结果：

定义一个返回不同类型的运算符：

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){}
//定义为扩展函数
operator fun Char.times(count:Int):String{
    return this.toString().repeat(count)
}

fun main(args: Array<String>) {
    val char1 = 'a'
    println(char1*3)
}

运行结果：

注意：没有用于位运算的特殊运算符

2.重载复合赋值运算符

通常情况下，当你定义plus之类的运算符时，Kotlin不止支持+操作，也支持+=。像+=、-=等这些运算符被称为复合赋值运算符。

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){}
//定义为扩展函数
operator fun Point.plus(other: Point):Point{
    return Point(x+other.x,y+other.y)
}
fun main(args: Array<String>) {
    var p1 = Point(10,20)
    p1 += Point(30,40)
    println(p1)
}

运行结果：

在一些情况下，定义+=运算可以修改变量所引用的对象，并不会创建新的引用。

如果你定义了一个返回值为Unit，名为plusAssign的函数，Kotlin在用到+=的地方调用它，其他二元运算类推。

operator fun <T> MutableCollection<T>.plusAssign(element: T){
    this.add(element)
}
fun main(args: Array<String>) {
    val number = ArrayList<Int>()
    number += 66
    println(number)
}

operator fun <T> MutableCollection<T>.plus(element: T):Any{
    return this.add(element)
}
fun main(args: Array<String>) {
    val number = ArrayList<Int>()
    number += 66
    println(number)
}

运行结果：

3.重载一元运算符

重载一元运算符的方式跟前面相似：用预定义的函数名让operator进行修饰。

operator fun Point.unaryMinus():Point{
    return Point(-this.x,-this.y)
}
fun main(args: Array<String>) {
    val p1 = Point(10,20)
    println(-p1)
}

运行结果：

下面列举一元运算符对应的函数名：

表达式	函数名
+a	unaryPlus
-a	unaryMinus
!a	not
++a a++	inc
--a a--	dec

定义一个自增函数：

operator fun BigDecimal.inc() = this+BigDecimal.ONE

fun main(args: Array<String>) {
    var x = BigDecimal.ZERO
    println(x++)
    println(++x)
}

运行结果：

三、重载比较运算符

与算数运算符一样，在Kotlin中，可以对任何对象使用比较运算符（==、!=、>、<等）

1.等号运算符：“equals”

等式校验==被转换成equals函数，以及null的校验：

package com.houbo.shizhan

data class Point(val x:Int,val y:Int){
    override fun equals(other: Any?): Boolean {
        if (this===other) return true
        if (other!is Point) return false
        return other.x==x && other.y==y
    }
}

fun main(args: Array<String>) {
    println(Point(10,20)== Point(10,20))
    println(Point(10,20)!= Point(5,5))
    println(null==Point(3,3))
}

运算结果：

注意：===号类似于java中==号，用于判断是否是同一个对象。

2.排序运算符：compareTo

Kotlin支持Comparable接口。但是接口中定义的compareTo方法可以按约定调用，比较运算符最终被转化成compareTo。

实现compareTo方法：

class Person1(val firstName:String,val lastName: String):Comparable<Person1>{
    override fun compareTo(other: Person1): Int {
        return compareValuesBy(this,other,Person1::firstName,Person1::lastName)
    }
}
fun main(args: Array<String>) {
    val p1 = Person1("bob","smith")
    val p2 = Person1("Alice","jhon")
    println(p1<p2)
}

运行结果：

疑问？为什么equals和compareTo方法不用operator修饰呢？因为operator修饰符已经在基类接口中定义了，因此重写时无需重复定义。

四、集合与区间的定义

处理集合最常见的一些操作是通过下标来获取或者设置值，可以使用in运算符来检查一个元素是否在集合中。

1.通过下标来访问元素：get和set

实现get约定：

operator fun Point.get(index:Int):Int{
    return when(index){
        0 -> this.x
        1 -> this.y
        else -> throw Exception("ex")
    }
}
fun main(args: Array<String>) {
    val p = Point(10,20)
    println(p[1])
}

运行结果：

实现set约定：

operator fun Point.set(index: Int,value:Int){
    when(index){
        0 -> this.x = value
        1 -> this.y = value
        else -> throw Exception("ex")
    }
}
fun main(args: Array<String>) {
    val p = Point(10,20)
    p[0] = 40
    println(p)
}

运行结果：

2.in 的约定

in运算符用于检查一个元素是否在某个集合中，相应的函数时contains。

实现in约定：

data class Rectangle1(val upperLeft:Point,val lowerRight:Point)
operator fun Rectangle1.contains(p:Point):Boolean{
    return p.x in upperLeft.x until lowerRight.x && p.y in upperLeft.y until lowerRight.y
}

fun main(args: Array<String>) {
    val rec = Rectangle1(Point(10,20), Point(50,50))
    println(Point(20,30) in rec)
}

运行结果：

3.rangeTo的约定

要创建一个区间，使用..语法，运算符调用的是rangeTo方法。

fun main(args: Array<String>) {
    val now = LocalDate.now()
    val vocation = now..now.plusDays(10)
    println(now.plusWeeks(1) in vocation)
}

运行结果：

4.在for循环中使用iterator约定

实现日期区间迭代器：

operator fun ClosedRange<LocalDate>.iterator():Iterator<LocalDate> =
        object : Iterator<LocalDate>{
            var current = start
            override fun hasNext(): Boolean {
                return current <= endInclusive
            }

            override fun next(): LocalDate {
                return current.apply { current = plusDays(1) }
            }
        }

fun main(args: Array<String>) {
    val newYear = LocalDate.ofYearDay(2017,1)
    val daysOff = newYear.minusDays(1)..newYear
    for (dayOff in daysOff){
        println(dayOff)
    }
}

运行结果:

五、解构声明和组件函数

这个功能允许你展开单个复合值，并用它来初始化多个变量，解构声明的函数是componentN

fun main(args: Array<String>) {
    var p = Point(10,20)
    var (x,y) = p
    println("x:$x y:$y")
}

运行结果：

使用解构声明来返回多个值：

data class NameComponenets(val name:String,val extension:String)
fun splitFileName(fullName:String):NameComponenets{
    val result = fullName.split('.',limit = 2)
    return NameComponenets(result[0],result[1])
}

fun main(args: Array<String>) {
    val (name,ext) = splitFileName("test.kt")
    println(name)
    println(ext)
}

运行结果：