本篇文章为大家详细的介绍Koltin
特有的操作符重载
。或许对于有编程经验的朋友来说,操作符这个词绝对不陌生,就算没有任何编辑基础的朋友,数学中的算数运算符也绝不陌生。例如(+、-、*、/、>、<、>=、<=
)等。而算数运算符是编程语言中的一种操作符而已。就算你没有任何基础,也请你详细的看完这篇文章,我相信你会很有收获的。
目录
一、约定
所谓预定:即指
Kotlin
允许我们为自己的类型提供预定义的一组操作符的实现。这些操作符具有固定的符号表示(如+
或*
)和固定的优先级。为实现这样的操作符,我们为相应的操作类型提供了一个固定名字的成员函数或扩展函数。这样的技术,称为约定
因为由类实现的接口集是固定的,而Kotlin不能为了实现其他接口而修改现有的类,因此一般通过扩展函数的机制来实现为现有的类增添新的约定方法,从而适应任何现有的Java
类。
具体的实例请继续往下看...
二、操作符与操作符重载
根据操作数据个数的不同,分为两种操作类型:
- 一元操作:即指操作数只有一个的情况
- 二元操作:即指操作数存在二两或多个的情况。特别说明:在存在多个操作数的情况下,会用复合运算或拆分为多个运算。
2.1、一元操作
一元操作:即指一个操作数的情况,有三种一元操作:
+
表示为操作数实现一个正号
的意思,其操作数为数值型-
表示为操作数实现一个负号
的意思,其操作数为数值型!
表示取反的意思,其操作数为boolean类型
这里提供一个表格直观的展示:
操作符 | 重载 |
---|---|
+a | a.unaryPlus() |
-a | a.unaryMinus() |
!a | a.not() |
例:
var a = 1
var b = -2
var c = true
var d = false
// Java实现
println("+a = ${+a}\t -a = ${-a}\t !c = ${!c}")
println("+b = ${+b}\t -b = ${-b}\t !d = ${!d}")
// Kotlin实现,值得注意的是Kotlin同样可以实现上面的写法
println("+a = ${a.unaryPlus()}\t -a = ${a.unaryMinus()}\t !c = ${c.not()}")
println("+b = ${b.unaryPlus()}\t -b = ${b.unaryMinus()}\t !d = ${d.not()}")
输出结果为:
+a = 1 -a = -1 !c = false
+b = -2 -b = 2 !d = true
+a = 1 -a = -1 !c = false
+b = -2 -b = 2 !d = true
2.2 二元操作
二元操作:即指操作数存在二两或多个的情况。
2.2.1、简单的二元操作
简单的二元操作有:
a + b
,表示两个操作数相加,值得注意的是若某一个操作数为String
类型时。其返回值为String
类型,当且仅当两个操作数都为数值型时,其返回值才会数值型。a - b
,表示两个操作数相减,返回值为数值型a * b
,表示两个操作数相乘,返回值为数值型a / b
,表示两个操作数相除,返回值为数值型a % b
,表示两个操作数相除后的余数,官方称之为模
,即a
模以b
。返回值为Int
型a .. b
,表示范围(区间),这里不详细说明,在下面一点的区间操作符一起讲解。
这里提供一个表格直观的展示:
操作符 | 重载 |
---|---|
a + b | a.plus(b) |
a - b | a.minus(b) |
a * b | a.tiems(b) |
a / b | a.div(b) |
a % b | a.rem(b) 或 a.mod(b) |
a .. b | a.rangTo(b) |
这里值得注意的是:a % b
的重载为a.rem()
或a.mod()
。不过a.mod()
是Koltin1.0
版本的重载方法,现在已经弃用了,Koltin1.1
以及以上版本使用a.rem()
重载方法
例
// 简单的二元操作
val a = 10
val b = 2
val c = "2"
val d = "Kotlin"
// Java实现
println("a + d = " + a + d)
println("c + d = " + c + d)
println("a + b = ${a + b} \t a - b = ${a - b} \t a * b = ${a * b} \t a / b = ${a / b} \t a % b = ${a % b}")
// Kotlin实现,上面同样可以实现
println("a .. b = ${a .. b}")
// println("a + d = ${a + d}") 错误:字符串模板限制只能为数值型
println("a + b = ${a.plus(b)} \t a - b = ${a.minus(b)} \t a * b = ${a.times(b)} \t a / b = ${a.div(b)} \t a % b = ${a.rem(b)} \t a .. d = ${a.rangeTo(b)}")
// println(a.plus(d)) 错误:因为第一个操作数`a`限制了其plus()方法的参数,
// println(d.plus(a)) 正确:因为plus()方法的参数为超(Any)类型
输出结果为:
a + d = 10Kotlin
c + d = 2Kotlin
a + b = 12 a - b = 8 a * b = 20 a / b = 5 a % b = 0
a .. d = 10..2
a + b = 12 a - b = 8 a * b = 20 a / b = 5 a % b = 0 a .. d = 10..2
在此处贴上Kotlin
操作符中plus()
函数的源码。
public operator fun plus(other: Byte): Double
public operator fun plus(other: Short): Double
public operator fun plus(other: Int): Double
public operator fun plus(other: Long): Double
public operator fun plus(other: Float): Double
public operator fun plus(other: Double): Double
可以看出,plus()
方法只支持数值型。详细的其他操作符重载可以看源码中的Primitives.kt
文件。其中的operator
修饰符为定义一个重载操作符函数的关键字。在下面会实例讲解。
2.2.2、复合二元操作
复合的二元操作有:
a += b
,表示第一个操作数的的值为第一个操作数加上第二个操作数,值得注意的是若某一个操作数为String
类型时。其返回值为String
类型,当且仅当两个操作数都为数值型时,其返回值才会数值型。a -= b
,表示第一个操作数的的值为第一个操作数减去第二个操作数,返回值为数值型a *= b
,表示第一个操作数的的值为第一个操作数乘以第二个操作数,返回值为数值型a /= b
,表示第一个操作数的的值为第一个操作数除以第二个操作数,返回值为数值型a %= b
,表示第一个操作数的的值为第一个操作数模以第二个操作数 。返回值为Int
型
这里提供一个表格直观的展示:
操作符 | 表示 | 重载 |
---|---|---|
a += b | a = a + b | a = a.plus(b) |
a -= b | a = a - b | a = a.minus(b) |
a *= b | a = a * b | a = a.tiems(b) |
a /= b | a = a / b | a = a.div(b) |
a %= b | a = a % b | a = a.rem(b) |
2.2.2.1 普通的二元操作
这里所指的普通,是对操作数为普通的类型而言。
例:Java
版本
var b = 2
var a = 10
var c = "Kotlin"
a += b
print("a = $a \t")
// 主要演示字符串的+=
c += a
print("c = $c \t")
a = 10
a -= b
print("a = $a \t")
a = 10
a *= b
print("a = $a \t")
a = 10
a /= b
print("a = $a \t")
a = 10
a += b
print("a = $a \t")
输出结果为:
a = 12 c = Kotlin12 a = 8 a = 20 a = 5 a = 12
或许你会说这里为什么没有Kotlin
的版本呢?你在看官方文档或者其他人一些博客文章的时候可能有这样a += b <=> a.plusAssign()
的操作。但是我告诉你a.plusAssign()
不是这样用的,你可以看源码知道primitives.kt
文件中肯本就不存在plusAssign()
这个方法。因为Koltin
中赋值不是表达式。即 a += b <=> a = a + b
在Kotlin
中是a = a.plus(b)
。
还有一点就是:如果我的第一个操作数定义为val(不可变)
类型时,a += b
这个表达式会直接爆红。
例:Koltin
版本
a = 10
a = a.plus(b)
println("a = $a \t")
a = 10
c = c.plus(a)
print("c = $c \t" )
a = 10
a = a.minus(b)
println("a = $a \t")
a = 10
a = a.times(b)
println("a = $a \t")
a = 10
a = a.div(b)
println("a = $a \t")
a = 10
a = a.rem(b)
println("a = $a \t")
输出结果为:
a = 12 c = Kotlin1210 a = 8 a = 20 a = 5 a = 0
上面说到了在源码
primitievs.kt
文件中不存在plusAssign()
、minusAssign()
、timesAssign()
、divAssign()
、remAssign()
这些方法。那为什么官方文档上会存在呢?这里这里不做详解,但是我会在自定义重载操作符方法的时候给大家说明,请大家详细的往下看,一些更高级的操作
2.2.2.2 高级的二元操作
这里的高级二元操作,指的是操作数为一个集合,不过只能使用
+=
和-=
。即(plusAssign()
和minusAssign()
)
实例讲解:
var arrA = arrayListOf<String>("1","2","3","4")
var arrB = arrayListOf<String>("1","2","3","4")
arrA.plusAssign(arrB)
for (a in arrA){
print("$a \t")
}
输出结果为:
1 2 3 4 1 2 3 4
源码分析:MutableCollections.kt
文件下
/**
* Adds the specified [element] to this mutable collection.
*/
@kotlin.internal.InlineOnly
public inline operator fun <T> MutableCollection<in T>.plusAssign(element: T) {
this.add(element)
}
/**
* Adds all elements of the given [elements] collection to this mutable collection.
*/
@kotlin.internal.InlineOnly
public inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>) {
this.addAll(elements)
}
结果可以看出,只是调用了集合中我们熟知的add()
、addAll()
、remove()
等方法。没什么用!
2.3、比较操作
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
2.4、位运算操作
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
2.4、区间操作
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
2.5、集合操作
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
三、自定义操作符的重载方法
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
四、和Java的对比
由于篇幅原因,请看Kotlin——你所不知的操作符用法(二)
五、总结
这篇文章,主要讲解了
Kotlin
中常用的操作符以及重载方法。其中的第一部分只是介绍了其概念,在第二节在才开始讲解了其用法及实例说明。重点在于二元操作中的复合运算一节,千万不要被别人的博客和翻译文档所误导。上面的实例都是我一个一个实验过后才写出来的。实践出真理,不然我也不知道这个a += b
等所
对应的a.plusAssign(b)
等会这么坑。
如果各位大佬看了之后感觉还阔以,就请各位大佬随便star
一下,您的关注是我最大的动力。
我的个人博客:Jetictors
我的github:Jetictors
我的掘金:Jetictors