Kotlin学习_运算符重载

在前面写了关于集合和范围的内容,里面包括了一点运算符重载的内容,在这里我们来详细了解运算符重载的知识,内容参考《Kotlin实战》(Kotlin in Action)。

什么是运算符重载?

简单来说,就是Kotlin通过调用自己代码中定义特定的函数名的函数(成员函数或者扩展函数),并且用operator修饰符标记,来实现特定的语言结构,例如如果你在一个类上面定义了一个特定函数命名plus的函数,那么按照Kotlin的约定,可用在这个类的实例上使用+运算符,下面是代码。

用于重载运算符的所有函数都必须使用operator关键字标记。

日本编程丛书-图片源于网络

1
2
3
4
5
6
7
8
9
10
11
12
// 一个简单的数据类
data class Foo(val x: Int, val y: Int) {
operator fun plus(other: Foo) : Foo = Foo(x + other.x, y + other.y)
}
fun main(args: Array<String>) {
// 使用的时候
val f1 = Foo(10, 20)
val f2 = Foo(30, 40)
// 直接用+运算符代替plus函数,事实上会调用plus函数
println(f1 + f2) // 打印内容为Foo(x=40, y=60)
}

那么Java如何调用运算符函数呢?

重载的运算符实际上是被定义成一个函数,Java调用Kotlin运算符就跟调用普通函数一样调用就行。

重载算术运算符

算术运算符包括二元运算符、复合赋值运算符、一元运算符,当Kotlin在给一个集合添加元素的时候,是调用add方法,用到重载的话,我们就可以直接用+=来进行这个操作,就会显得更加的优雅。。。

1
2
3
4
5
6
7
8
9
10
11
fun Any.println() = println(this)
fun main(args: Array<String>) {
val list = arrayListOf(1, 2 ,3)
list.println() // 打印[1, 2, 3]
list.add(4)
list.println() // 打印[1, 2, 3, 4]
list += 5
list.println() // 打印[1, 2, 3, 4, 5]
}

重载二元算术运算符

二元算术运算符就是常见的+-*/和取余%,优先级与数学的是一样的,*/%要高于+-的优先级。

下面我们列举对应的函数名:

表达式 函数名
a * b times
a / b div
a % b rem,mod(弃用)
a + b plus
a - b minus

下面我们来写个类,里面包含这几种函数,同时还有扩展函数的定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
fun Any.println() = println(this)
// Extension
operator fun Foo.minus(other: Foo): Foo = Foo(x - other.x, y - other.y)
operator fun Foo.div(other: Foo): Foo = Foo(x / other.x, y / other.y)
data class Foo(val x: Int, val y: Int) {
operator fun plus(other: Foo): Foo = Foo(x + other.x, y + other.y)
operator fun times(other: Foo): Foo = Foo(x * other.x, y * other.y)
operator fun rem(other: Foo): Foo = Foo(x % other.x, y % other.y)
}
fun main(args: Array<String>) {
val f1 = Foo(30, 40)
val f2 = Foo(10, 20)
(f1 - f2).println() // 打印Foo(x=20, y=20)
(f1 + f2).println() // 打印Foo(x=40, y=60)
(f1 * f2).println() // 打印Foo(x=300, y=800)
(f1 / f2).println() // 打印Foo(x=3, y=2)
(f1 % f2).println() // 打印Foo(x=0, y=0)
}

除了定义相同类型的运算数之外,还能定义运算数类型不同的运算符:

1
2
3
4
5
6
7
8
data class Foo(val x: Int, val y: Int) {
operator fun times(other: Double): Foo = Foo((x * other).toInt(), (y * other).toInt())
}
fun main(args: Array<String>) {
val f1 = Foo(30, 40)
(f1 * 1.5).println() // 打印Foo(x=45, y=60)
}

当你通过这样子去调用这个运算符的时候

1
(1.5 * f1).println()

这时候,编译器会提示你出错了

为什么会这样呢?

因为Kotlin的运算符不会自动至此交换性(交换运算符的左右两边)。

那要怎么样才能那样写呢?

需要定义一个单独的运算符

1
operator fun Double.times(other: Foo): Foo = Foo((this * other.x).toInt(), (this * other.y).toInt())

这样子就能直接支持运算符两边互换使用了。。。

1
2
(f1 * 1.5).println()
(1.5 * f1).println()

运算符函数不是单一返回类型的,也是可以定义不同的返回类型,下面举个栗子:

1
2
3
4
5
operator fun Char.times(count: Int): String = toString().repeat(count)
fun main(args: Array<String>) {
('a' * 3).println() // 打印aaa
}

在上面的代码中,这个运算符是Char类型的扩展函数,参数类型是Int类型,所以是Char * Int这样的操作,返回类型是String

注意:运算符和普通函数一样,可以重载operator函数,可以定义多个同名,但是参数不一样的方法。

重载复合赋值运算符

什么是复合赋值运算符?
类似于+=这样的,合并了两部操作的运算符,同时赋值,称为符合运算符。

下面我们列举对应的函数名:

表达式 函数名
a += b timesAssign
a /= b divAssign
a %= b remAssign
a += b plusAssign
a -= b minusAssign
1
2
3
4
5
fun main(args: Array<String>) {
var f1 = Foo(1, 2)
f1 += Foo(3, 4)
f1.println() // 打印Foo(x=4, y=6)
}

上面的+=等同于f1 = f1 + Foo(3, 4),这些操作当然是只对可变变量有效的。

默认情况下,复合赋值运算符是可以修改变量所引用的对象,同时重新分配引用,但是在将一个元素添加到一个可变集合的时候,+=是不会重新分配引用的:

1
2
3
4
5
fun main(args: Array<String>) {
val list = mutableListOf<Int>()
list += 42
list.println() // 打印[42]
}

同样我们可以对复合赋值运算符进行重载,同样可以定义多个同名,但是参数不一样的方法:

1
2
3
4
5
6
7
8
9
operator fun MutableCollection<Int>.plusAssign(element: Int) {
this.add(element - 1)
}
fun main(args: Array<String>) {
val list = mutableListOf<Int>()
list += 42
list.println() // 打印[41]
}

如果在plusplusAssign两个函数同时被定义且适用,那么编译器就会报错,最好在设计新类的时候保持(可变性)一致,尽量不同时定义plusplusAssign运算。如Foo类是不可变的,那么只提供plus运算,如果一个类是可变的,如构造器,那么只需提供plusAssign和类似的运算就够了。

实际上+=可以被转换为plus或者plusAssign函数调用,而Kotlin的标准库中为集合支持这两种方法。

  • +-运算符会返回一个新的集合。
  • +=-=用于可变集合,会修改集合,如果是只读,那么就会返回一个修改过的副本,也就是说只有在只读集合被定义为var类型的时候,才能使用+=-=
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fun main(args: Array<String>) {
// 可变类型
val list = mutableListOf<Int>(1, 2)
// += 修改list
list += 3
// + 返回一个新的List
val newList = list + listOf<Int>(4, 5) // 除了使用单个元素参数,也可使用元素类型相同的集合
list.println() // 打印[1, 2, 3]
newList.println() // 打印[1, 2, 3, 4, 5]
var varList = listOf<Int>(1, 2)
// 只读集合类型为var
varList.println() // 打印[1, 2]
varList += 3
varList.println() // 打印[1, 2, 3]
}

重载一元运算符

Kotlin中允许重载一元运算符,如-a,+a等等,同样我们列举支持的一元运算符和对应的函数名:

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

重载一元运算符过程与前面一样,通过预先定义的一个名称来声明函数(成员函数或者扩展函数),并且用operator修饰符标记。

注意:一元运算符是没有参数的。

1
2
3
4
5
6
7
8
data class Foo(val x: Int, val y: Int)
operator fun Foo.unaryMinus() = Foo(-x, -y)
fun main(args: Array<String>) {
val f1 = Foo(1, 2)
(-f1).println() // 打印Foo(x=-1, y=-2)
}

当重载自增自减运算符符是,编译器自动支持前缀--a和后缀a--语义。

1
2
3
4
5
6
7
operator fun BigDecimal.inc() = this + BigDecimal.ONE
fun main(args: Array<String>) {
var bd = 0
(bd++).println() // 打印0
(++bd).println() // 打印2
}

重载比较运算符

比较运算符,可以在除了基本数据类型外的任意对象上使用,当Java中使用equalscompareTo时,在Kotlin中,直接用运算符重载。
比较运算符分为等号运算符和排序运算符。

表达式 函数名
a == b a?.equals(b) ?: (b === null)
a != b !(a?.equals(b) ?: (b === null))
a > b a.compareTo(b) > 0
a < b a.compareTo(b) < 0
a >= b a.compareTo(b) >= 0
a <= b a.compareTo(b) <= 0

等号运算符equals

在我们平时使用判断字符串是否与某个字符串相等的时候,会使用equals函数来判断,然而在Kotlin中,我们可以是用==来代替equals函数,~=来代替!qeuals
在Java中如果使用null对象来equals的话,会爆空指针异常,而Kotlin中的==是支持可空类型的,因为会先判断是否为空,如a == b会先检查a是否为空,如果不是,就会调用a.equals(b),否则只有两个参数都是空值,结果才为真。

下面我们来重载equals运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
data class Foo(val x: Int, val y: Int) {
override operator fun equals(other: Any?): Boolean = when {
// 使用恒等运算符来判断两个参数是否同一个对象的引用
other === this -> true
other !is Foo -> false
else -> other.x == x && other.y == y
}
}
fun main(args: Array<String>) {
val f1 = Foo(1, 2)
val f2 = Foo(1, 2)
val f3 = Foo(10, 20)
(f1 == f2).println() // true
(f1 == f2).println() // true
(f1 != f2).println() // false
(null == f1).println() // false
}

注意:===与Java一样,检查两个参数是否是同一个对象的引用,如果是基本数据类型,检查值是否相同,===!==不能被重载。

排序运算符compareTo

在Java中,基本数据类型集合排序通常都是使用<>来比较,而其他类型需要使用element1.compareTo(element2)来比较的。而在Kotlin中,通过使用比较运算符(>``<``>=``<=)来进行比较。

比较运算符会被转换成compareTo函数,compareTo的返回类型必须为Int

1
2
3
4
5
6
7
class Person(private val firstName: String, private val lastName: String) : Comparable<Person> {
override fun compareTo(other: Person): Int = compareValuesBy(this, other, Person::lastName, Person::firstName)
}
fun main(args: Array<String>) {
(Person("Alice", "Smith") < Person("Bob", "Johnson")).println() // 打印false
}

compareValuesBy函数是按顺序依次调用回调方法,两两一组分别做比较,然后返回结果,如果则返回比较结果,如果相同,则继续调用下一个,如果没有更多回调来调用,则返回0。

override标记

Any

Comparable

从上面可以看到,equalscompareTo都是被override标记的,之所以会被标记,是因为在Any类中已经定义了equals函数,而所有的对象都默认继承Any类,所有才重载的时候需要使用override标记,而且equals不能定义为扩展函数,因为Any类的实现是重要优先于扩展函数。
同样,compareToComparable接口中已经定义了,所有在重载的时候,需要使用override标记。