Kotlin基础语法 三、运算符与运算符重载

1. 一、运算符

Kotlin 的运算符都是以方法形式来实现的，这些运算符都具有特定的符号和固定的优先级，各种运算符对应的方法名都是固定的，我们只要为某类型提供了特定名称的方法，就可以对该类型的对象进行运算

1.1、一元运算符

一元运算符:即只有一个操作数

1.1.1）简单的一元运算符：

1. ）+ 表示为操作数实现一个正号的意思，其操作数为数值型，对应 的方法unaryPlus()
2. ）- 表示为操作数实现一个负号的意思，其操作数为数值型，对应的方法unaryMinus()
3. ）! 表示取反的意思，其操作数为boolean类型，对应的方法not()

1.1.2）自增、自减运算符：

与Java相同，主要有4种情况：
后缀自增：表示为操作数进行自增操作，其操作数为数值型。例如：a++
后缀自减：表示为操作数进行自减操作，其操作数为数值型。例如：a–
前缀自增：表示为操作数进行自增操作，其操作数为数值型。例如：++a
前缀自减：表示为操作数进行自增操作，其操作数为数值型。例如：—a

前缀操作和后缀操作是有着明显的区别的：
后缀操作是第一次调用的时候不执行自身。在第二次开始进行自增或自减操作。
前缀操作是第一次调用的时候就执行自增或自减操作

1.2 二元运算符

二元运算符：即指操作数存在二两或多个的情况。

1.2.1）简单的二元运算符：

a + b，表示两个操作数相加，值得注意的是若某一个操作数为String类型时。其返回值为String类型，当且仅当两个操作数都为数值型时，其返回值才会数值型。对应的方法plus()
a - b，表示两个操作数相减，返回值为数值型，对应的方法minus()
a * b，表示两个操作数相乘，返回值为数值型，对应的方法 times()
a / b，表示两个操作数相除，返回值为数值型，对应的方法div()
a % b，表示两个操作数相除后的余数，官方称之为模，即a模以b 。返回值为Int型，对应的方法rem()
a … b，表示范围（区间），对应的方法rangeTo()

1.2.2、）广义赋值运算符

a += b，相等于a=a+b,表示第一个操作数的的值为第一个操作数加上第二个操作数，值得注意的是若某一个操作数为String类型时。其返回值为String类型，当且仅当两个操作数都为数值型时，其返回值才会数值型。
对应的方法是plusAssign()
a -= b，相等于a=a-b表示第一个操作数的的值为第一个操作数减去第二个操作数，返回值为数值型，对应的方法是minusAssign()
a = b，相等于a=ab表示第一个操作数的的值为第一个操作数乘以第二个操作数，返回值为数值型，对应的方法是timesAssign()
a /= b，相等于a=a/b表示第一个操作数的的值为第一个操作数除以第二个操作数，返回值为数值型，对应的方法divAssign()
a %= b，相等于a=a%b表示第一个操作数的的值为第一个操作数模以第二个操作数 。返回值为Int型，对应的方法是remAssign()

1.2.3 ） 索引访问运算符

String 类提供了get(index)方法，而数组和集合提供了get(index)方法和set(index,val)方法，他们的简写形式就是[index]

1.2.4 ）相等与不等运算符

== 判断两个操作数是否相同，等同于Java里的equals()方法，
!= 判断两个操作数是否不相同
=== 用于判断两个对象的内存地址是否相同

1.2.5）比较运算符

大于
< 小于
= 大于等于
<= 小于等于

比较运算符其实就是由 compareTo()方法来实现的，而该方法是Comparable 接口中定义的方法，在 Java 中支持使用 compareTo()方法比较大小的对象，都可使用比较运算符进行计算

1.2.6 ） is 和 !is

相当于 Java 中的 instanceof 运算符，用于检查对象是否是某个类的实例。

1.2.7 ）in 和 !in

对应的方法是contains，a in b 相当于 b.contains(a)，用于检查 a 是否是 b 内的元素， b 可以是字符串、数组、集合、区间
示例：
val a = “1”
val b = “123”
val c = arrayOf(“1” , “2” , “3”)
if (a in b) {
Log.e("------" , “a在b内”)
}
if (a in c) {
Log.e("------" , “a在c内”)
}

1.2.8 ）区间运算符

这里简单介绍一下区间，具体可以去学习kotlin区间与集合的相关知识

闭区间运算符…
a…b 用于定义一个从整数a到整数b 之间所有整数的闭区间，a 和 b 这两个边界也包含在内，并且 a不能大于b，否则程序运行时将会报错。对应的方法是rangeTo， a…b相当于a.rangeTo(b)
如果边界 a与边界b值相等，就会产生一个只包含一个值的区间，该区间只包含一个边界值
示例：
val range = 2…6
for (i in range) {
Log.e("------" , i.toString())
}

半开区间运算符 until
a until b用于定义一个从整数a 到整数 b的之间所有值的区间，包含边界值a但不包含边界值b，并且a不能大于b，对应的方法是 until(), a until b 相当于a.until(b)
如果边界a与边界b值相等，就会产生一个空区间，该区间不包含任何值

反向闭区间运算符 downTo
a downTo b 用于定义一个从大到小（整数a 到 整数b ）的闭区间，要求整数b不能大于整数a。对应的方法是 downTo()，a downTo b 相当于 a.downTo(b)

区间步长
区间的默认步长都是1，通过step运算符可以显式指定区间的步长.
示例：
for (i in 0…6 step 2) {
Log.e("------" , i.toString())
}

1.2.10 ）位运算符

and(bits) 按位与
or(bits) 按位或
inv(bits) 按位非
xor(bits) 按位异或
shl(bits) 左移运算符
shr(bits) 右移运算符
ushr(bits) 无符号右移运算符

1.2.11）其他运算符 …

2. 运算符重载

kotlin中所有都是对象
Kotlin 的运算符都是以方法形式来实现的。
比如我们运行 a+b ，如果a和b 都是数字那么a+b就标识加法操作，如果 a和b 都是字符串，那么就是字符串连接成一个新的字符串,那么编译器是怎么识别一个加号不同的行为呢？实际上是数据类型使用名称相同的函数的重载 ，编译器在遇到 +号的时候会自动把他理解为要执行这个函数，然后执行不同的操作，比如 + 号的应该重载为plus()方法，所有的数据类型都应该重载这个方法，执行 a+b 实际上是执行a.plus(b)，对于整数的plus(),它执行的是加法，对于字符串的plus()，它执行的是字符串的连接
进一步，我们查看Int类的代码：
可以看到有 前缀是 operator 的方法 plus（）

public class Int private constructor() : Number(), Comparable<Int> {
   
...省略其他代码
     /** Adds the other value to this value. */
    public operator fun plus(other: Byte): Int
    /** Adds the other value to this value. */
    public operator fun plus(other: Short): Int
    /** Adds the other value to this value. */
    public operator fun plus(other: Int): Int
    /** Adds the other value to this value. */
    public operator fun plus(other: Long): Long
    /** Adds the other value to this value. */
    public operator fun plus(other: Float): Float
    /** Adds the other value to this value. */
    public operator fun plus(other: Double): Double
...省略其他代码}
}

查看String类的代码：
也可以看到有一个可以 前缀是 operator 的方法 plus（）

public class String : Comparable<String>, CharSequence {
    companion object {}

    public operator fun plus(other: Any?): String

    public override val length: Int

    public override fun get(index: Int): Char

    public override fun subSequence(startIndex: Int, endIndex: Int): CharSequence

    public override fun compareTo(other: String): Int
}

同样的，只要重载这些方法，我们就可以为任意类添加这些运算符，重载运算符的方法需要用 operator 修饰符进行标记

运算符重载示例：

如下：我们定义了一个类FourNumber，它有四个整数变量，one，two，three，four，然后我们重载了plus方法，我们希望两个FourNumber相加 会把它们的四个整数变量全加起来返回。

data class FourNumber(val one : Int , val two : Int , val three : Int , val four : Int) {
    operator fun plus(other : FourNumber) : Int {
        return one + two + three + four + other.one + other.two + other.three + other.four
    }
}
val a = FourNumber(1 , 2 , 3 , 4)
val b = FourNumber(5 , 6 , 7 , 8)
val result = a + b
Log.e("相加的结果是" , result.toString())

运行结果：
相加的结果是: 36

结果符合我们的预期要求。