Kotlin——初级篇（五）：操做符与操做符重载一

本篇文章为你们详细的介绍Koltin特有的操做符重载。或许对于有编程经验的朋友来讲，操做符这个词绝对不陌生，就算没有任何编辑基础的朋友，数学中的算数运算符也毫不陌生。例如（+、-、*、/、>、<、>=、<=）等。而算数运算符是编程语言中的一种操做符而已。就算你没有任何基础，也请你详细的看完这篇文章，我相信你会颇有收获的。

目录

1、约定

所谓预约：即指Kotlin容许咱们为本身的类型提供预约义的一组操做符的实现。这些操做符具备固定的符号表示（如 + 或 *)和固定的优先级。为实现这样的操做符,咱们为相应的操做类型提供了一个固定名字的函数。这样的技术，称为约定

由于由类实现的接口集是固定的，而Kotlin不能为了实现其余接口而修改现有的类，所以通常经过扩展函数的机制来实现为现有的类增添新的约定方法，从而适应任何现有的Java类。

2、操做符与操做符重载

根据操做数据个数的不一样，分为两种操做类型：

1. 一元操做：即指操做数只有一个的状况
2. 二元操做：即指操做数存在二两或多个的状况。特别说明：在存在多个操做数的状况下，会用复合运算或拆分为多个运算。

2.一、一元操做

一元操做:即指一个操做数的状况，

2.1.一、简单的一元操做运算

这里分为三种状况有三种一元操做:

• + 表示为操做数实现一个正号的意思，其操做数为数值型
• - 表示为操做数实现一个负号的意思，其操做数为数值型
• ! 表示取反的意思，其操做数为boolean类型

提供一个表格直观的展现：

操做符	重载
+a	a.unaryPlus()
-a	a.unaryMinus()
!a	a.not()

例：

var a = 1
var b = -2
var c = true
var d = false

// 操做符实现
println("+a = ${+a}\t -a = ${-a}\t !c = ${!c}")
println("+b = ${+b}\t -b = ${-b}\t !d = ${!d}")

// 操做符重载实现
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.1.二、复杂的一元操做

复杂的一元操做符即指，对操做数进行自增、自减操做。和Java是同样的

这里主要有4种状况：

• 后缀自增：表示为操做数进行自增操做，其操做数为数值型。例如：a++
• 后缀自减：表示为操做数进行自减操做，其操做数为数值型。例如：a--
• 前缀自增：表示为操做数进行自增操做，其操做数为数值型。例如：++a
• 前缀自减：表示为操做数进行自增操做，其操做数为数值型。例如：--a

提供一个表格直观的展现：

操做符	重载	表示
a++	a.inc()	a = a.also{ a.inc() }
a--	a.dec()	a = a.also{ a.dec() }
++a	a.inc()	a = a.inc().also{ a = it }
--a	a.dec()	a = a.dec().also{ a = it }

解释：操做符++的重载为inc(),操做符--的重载为dec()。可是前缀操做和后缀操做是有着明显的区别的：

• 后缀操做是第一次调用的时候不执行自身。在第二次开始进行自增或自减操做。
• 前缀操做是第一次调用的时候就执行自增或自减操做

实例：

var a = 10
var b = 10
var c = 10
var d = 10

// 操做符实现
println("a++ = ${a++} \t b-- = ${b--} \t ++c = ${++c} \t --d = ${--d}")

// 操做符重载方式实现，或许你看不明白上表中代码，不过这不要紧，你只要记住上面前缀与后缀操做的区别就行
a.also { a.inc() }
b.also { b.dec() }
c.inc().also { c = it }
d.dec().also { d = it }
println("a = $a \t b = $b \t c = $c \t d = $d")

输出结果为：

a++ = 10     b-- = 10    ++c = 11    --d = 9
a = 10   b = 10      c = 11      d = 9

2.2 二元操做

二元操做：即指操做数存在二两或多个的状况。

2.2.一、简单的二元操做

简单的二元操做有：

• 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"

// 操做符实现
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}")

// 操做符重载实现
// 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)}")
// 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 + b = 12   a - b = 8   a * b = 20      a / b = 5   a % b = 0

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)

例: 操做符实现

var b = 2
var a = 10
var c = "Kotlin"

// 主要演示字符串的+=
c += a                          等价于  c = c.plus(a)
print("c = $c \t")

a += b                          等价于  a = a.plus(b)
print("a = $a \t")

a = 10
a -= b                          等价于  a = a.minus(b)
print("a = $a \t")

a = 10
a *= b                          等价于  a = a.tiems(b)
print("a = $a \t")

a = 10
a /= b                          等价于  a = a.div(b)
print("a = $a \t")

a = 10
a % b                          等价于  a = a.rem(b)
print("a = $a \t")

输出结果为：

c = Kotlin10    a = 12  a = 8   a = 20  a = 5   a = 0

或许你会说这里为何没有Kotlin的版本呢？你在看官方文档或者其余人一些博客文章的时候可能有这样a += b <=> a.plusAssign()的操做。可是我告诉你a.plusAssign()不是这样用的，你能够看源码知道primitives.kt文件中肯本就不存在plusAssign()这个方法。由于Koltin中赋值不是表达式。即 a += b <=> a = a + b在Kotlin中是a = a.plus(b)。不过数组与集合是同时存在plus()和plusAssign()这两个函数的。

还有一点就是：若是个人第一个操做数定义为val(不可变)类型时，a += b这个表达式会编译出错。

上面说到了在源码primitievs.kt文件中不存在plusAssign()、minusAssign()、timesAssign()、divAssign()、remAssign()这些方法。那为何官方文档上会存在呢？这里这里不作详解，可是我会在自定义重载操做符方法的时候给你们说明,请你们详细的往下看，一些更高级的操做

2.三、位运算操做

位运算操做：即对一个数进行位移运算。关于这个操做符的重载函数，我在前面讲解数据类型章节的时候已经讲解过，这里就很少作累述了。没有看过的朋友请参见Kotlin——初级篇（三）：数据类型详解

2.四、区间操做

区间操做符：便是符号..。值得注意的是这个操做符在Java中是不存在的，且两个操做数都是整型

操做符	表示	重载
a .. b	a 到 b 中间的值	a.rangeTo(b)

这个操做符通常用于for循环中，在条件判断中偶尔也会用到。

例：

val a = 1
val b = 5

// 操做符实现
val s = 3 in a .. b     // true,由于3在区间[1,5]以内
println("s = $s")
for (index in a .. b){
    print("index = $index \t")
}

// 操做符重载方式实现
val t = 3 in a.rangeTo(b)
println("t = $t")
for (index in a.rangeTo(b)){
    print("index = $index \t")
}

输出结果为：

s = true
index = 1   index = 2   index = 3   index = 4   index = 5   
t = true
index = 1   index = 2   index = 3   index = 4   index = 5

固然了，这些实例都是极其简单的。我在Kotlin——初级篇（四）：控制语句讲解这篇文章也是讲到过的。

总结

关于操做符重载，这里因为篇幅过长的缘由，后面的比较操做符，以及in与is、以及自定义操做符等都会在下一章讲解。敬请期待...

这篇文章，主要讲解了Kotlin中经常使用的操做符以及重载方法。其中的第一部分只是介绍了其概念，在第二节在才开始讲解了其用法及实例说明。重点在于二元操做中的复合运算一节，千万不要被别人的博客和翻译文档所误导。上面的实例都是我一个一个实验事后才写出来的。实践出真理，否则我也不知道这个a += b等所
对应的a.plusAssign(b)等会这么坑。

参考

这里参考了别人翻译的官方文档
以及另一篇很好的博文

源代码

若是各位大佬看了以后感受还阔以，就请各位大佬随便star一下，您的关注是我最大的动力。
个人我的博客：Jetictors
个人github：Jetictors
个人掘金：Jetictors

欢迎各位大佬进群共同研究、探索

QQ群号：497071402