操作符重载

在Kotlin中，操作符重载（Operator Overloading）允许你为类定义或修改运算符的行为。通过定义特定的函数，你可以自定义一些常见的运算符（如 +, -, *, / 等）的行为。Kotlin使用operator关键字来标记这些函数，以表明它们是用于操作符重载的。

1. 操作符重载的规则：

• 只能重载Kotlin预定义的操作符。
• 必须使用特定的函数名称，这些名称与操作符关联。

2. 操作符重载的语法：

operator fun operatorFunctionName(parameter: Type): ReturnType

3. 常见操作符及其重载函数：

1. 加法 (+)

   data class Point(val x: Int, val y: Int)
   
   operator fun Point.plus(other: Point): Point {
       return Point(this.x + other.x, this.y + other.y)
   }
   
   fun main() {
       val p1 = Point(1, 2)
       val p2 = Point(3, 4)
       val result = p1 + p2
       println(result)  // 输出：Point(x=4, y=6)
   }

2. 减法 (-)

   operator fun Point.minus(other: Point): Point {
       return Point(this.x - other.x, this.y - other.y)
   }
   
   fun main() {
       val p1 = Point(5, 6)
       val p2 = Point(2, 3)
       val result = p1 - p2
       println(result)  // 输出：Point(x=3, y=3)
   }

3. 乘法 (*)

   operator fun Point.times(scale: Int): Point {
       return Point(this.x * scale, this.y * scale)
   }
   
   fun main() {
       val p = Point(2, 3)
       val result = p * 3
       println(result)  // 输出：Point(x=6, y=9)
   }

4. 除法 (/)

   operator fun Point.div(scale: Int): Point {
       return Point(this.x / scale, this.y / scale)
   }
   
   fun main() {
       val p = Point(6, 9)
       val result = p / 3
       println(result)  // 输出：Point(x=2, y=3)
   }

5. 取负号 (unaryMinus)

   operator fun Point.unaryMinus(): Point {
       return Point(-this.x, -this.y)
   }
   
   fun main() {
       val p = Point(3, 4)
       val result = -p
       println(result)  // 输出：Point(x=-3, y=-4)
   }

6. 比较操作符 (<, <=, >, >=) 这些操作符通常用于比较对象的大小，比如 compareTo 方法：

   data class Rectangle(val width: Int, val height: Int)
   
   operator fun Rectangle.compareTo(other: Rectangle): Int {
       return (this.width * this.height) - (other.width * other.height)
   }
   
   fun main() {
       val r1 = Rectangle(2, 3)
       val r2 = Rectangle(3, 4)
       println(r1 < r2)  // 输出：true
   }

7. 索引访问 ([]) 如果希望重载索引访问，可以重载 get 和 set 函数：

   class Matrix(private val data: Array<IntArray>) {
       operator fun get(i: Int, j: Int): Int {
           return data[i][j]
       }
   
       operator fun set(i: Int, j: Int, value: Int) {
           data[i][j] = value
       }
   }
   
   fun main() {
       val matrix = Matrix(arrayOf(intArrayOf(1, 2), intArrayOf(3, 4)))
       println(matrix[0, 1])  // 输出：2
       matrix[0, 1] = 5
       println(matrix[0, 1])  // 输出：5
   }

4. 其他可重载的操作符：

• ++/--: inc() 和 dec()
• 相等性检查 (== 和 !=): equals()
• 比较 (<, <=, >, >=): compareTo()
• 取模 (%): rem()
• 取反 (!): not()

通过操作符重载，Kotlin允许你定义更加直观且符合自然语言逻辑的操作，使得你的类更易于使用。