Operator overloading concept in Kotlin - Mini Project: Build & Apply

Operator overloading concept

📖 Scenario: Imagine you have a simple Point in 2D space with x and y coordinates. You want to add two points together using the + operator, just like adding numbers.

🎯 Goal: Build a Kotlin class Point that supports adding two points using the + operator by overloading it.

📋 What You'll Learn

Create a class called Point with two Int properties: x and y

Create a variable called point1 with x = 2 and y = 3

Create a variable called point2 with x = 4 and y = 1

Add an operator function called plus inside Point to overload the + operator

Use the overloaded + operator to add point1 and point2 and store the result in result

Print the result point's x and y values

💡 Why This Matters

🌍 Real World

Operator overloading lets you use natural symbols like + or - with your own objects, making code easier to read and write, like adding points or complex numbers.

💼 Career

Understanding operator overloading is useful for Kotlin developers working on math libraries, games, graphics, or any domain where custom data types benefit from intuitive operations.

1

Create the Point class and two points

Create a class called Point with two Int properties: x and y. Then create two variables: point1 with x = 2 and y = 3, and point2 with x = 4 and y = 1.

Kotlin

class Point(val x: Int, val y: Int)

// Create point1 and point2 below
// Your code here

Hint

Use class Point(val x: Int, val y: Int) to create the class. Then create point1 and point2 as instances of Point.

2

Add operator function to overload +

Inside the Point class, add an operator function called plus that takes another Point as a parameter and returns a new Point with x and y added together.

Kotlin

class Point(val x: Int, val y: Int) {
    // Add operator function plus here
    // Your code here
}

val point1 = Point(2, 3)
val point2 = Point(4, 1)

Hint

Use operator fun plus(other: Point): Point inside the class to overload the + operator.

3

Add two points using + operator

Create a variable called result that adds point1 and point2 using the + operator.

Kotlin

class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

val point1 = Point(2, 3)
val point2 = Point(4, 1)

// Add point1 and point2 using + and store in result
// Your code here

Hint

Use val result = point1 + point2 to add the two points with the overloaded operator.

4

Print the result point coordinates

Print the x and y values of the result point using println in the format: x = <value>, y = <value>.

Kotlin

class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

val point1 = Point(2, 3)
val point2 = Point(4, 1)

val result = point1 + point2

// Print result coordinates
// Your code here

Hint

Use println("x = ${result.x}, y = ${result.y}") to show the coordinates.

Practice

1. What does operator overloading in Kotlin allow you to do?

easy

A. Disable operators for certain classes

B. Change the meaning of built-in types like Int or String

C. Create new operators not available in Kotlin

D. Use standard operators like + or * with your own classes

Solution

1. Step 1: Understand operator overloading purpose

   Operator overloading lets you define how operators like + work with your own classes.

2. Step 2: Check options meaning

   Only Use standard operators like + or * with your own classes correctly states this ability. Options A, B, and C are incorrect because Kotlin does not let you change built-in types, create new operators, or disable operators this way.

3. Final Answer:

   Use standard operators like + or * with your own classes -> Option D

4. Quick Check:

   Operator overloading = Use operators with custom classes [OK]

Hint: Operator overloading means using +, * with your own classes [OK]

Common Mistakes:

• Thinking you can create new operators
• Believing it changes built-in types
• Confusing disabling operators with overloading

2. Which of the following is the correct syntax to overload the plus operator in a Kotlin class?

easy

A. operator fun plus(other: MyClass): MyClass { ... }

B. fun plus(other: MyClass): MyClass { ... }

C. override fun plus(other: MyClass): MyClass { ... }

D. fun operator plus(other: MyClass): MyClass { ... }

Solution

1. Step 1: Recall operator function syntax

   In Kotlin, to overload an operator, the function must be marked with the keyword operator before the function declaration.

2. Step 2: Analyze options

   operator fun plus(other: MyClass): MyClass { ... } correctly uses operator fun plus(...). fun plus(other: MyClass): MyClass { ... } misses the operator keyword, C wrongly uses override, and D has incorrect keyword order.

3. Final Answer:

   operator fun plus(other: MyClass): MyClass { ... } -> Option A

4. Quick Check:

   Operator keyword before function = Correct syntax [OK]

Hint: Always put 'operator' before function to overload operators [OK]

Common Mistakes:

• Omitting the 'operator' keyword
• Using 'override' instead of 'operator'
• Placing 'operator' after 'fun'

3. What will be the output of this Kotlin code?

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    val p3 = p1 + p2
    println(p3)
}

medium

A. Point(x=4, y=6)

B. p1 + p2

C. Compilation error

D. Point(4, 6)

Solution

1. Step 1: Understand operator plus function

   The plus operator adds the x and y values of two Point objects and returns a new Point with summed coordinates.

2. Step 2: Calculate the result of p1 + p2

   p1 has (1, 2), p2 has (3, 4). Adding gives (4, 6). Printing p3 calls data class's toString(), which outputs 'Point(x=4, y=6)'.

3. Final Answer:

   Point(x=4, y=6) -> Option A

4. Quick Check:

   p1 + p2 = Point(x=4, y=6) [OK]

Hint: Data class toString shows property names; sum coordinates [OK]

Common Mistakes:

• Expecting just coordinates without property names
• Thinking '+' prints expression instead of result
• Assuming compilation error without operator keyword

4. Identify the error in this Kotlin code that tries to overload the minus operator:

class Counter(var count: Int) {
    fun minus(other: Counter): Counter {
        return Counter(count - other.count)
    }
}

medium

A. Wrong return type; should be Int instead of Counter

B. Missing 'operator' keyword before the minus function

C. Function name should be 'operatorMinus' instead of 'minus'

D. Cannot overload minus operator for classes

Solution

1. Step 1: Check operator overloading syntax

   To overload an operator in Kotlin, the function must have the 'operator' keyword before its declaration.

2. Step 2: Analyze the code

   The minus function lacks the 'operator' keyword, so Kotlin won't treat it as operator overloading, causing errors when using '-'.

3. Final Answer:

   Missing 'operator' keyword before the minus function -> Option B

4. Quick Check:

   Operator functions need 'operator' keyword [OK]

Hint: Operator functions must start with 'operator' keyword [OK]

Common Mistakes:

• Forgetting the 'operator' keyword
• Changing function name incorrectly
• Assuming operator overloading is not allowed

5. Given this Kotlin class:

class Vector(val x: Int, val y: Int) {
    operator fun plus(other: Vector) = Vector(x + other.x, y + other.y)
    operator fun times(scalar: Int) = Vector(x * scalar, y * scalar)
}

What is the result of this expression?

val v1 = Vector(2, 3)
val v2 = Vector(1, 1)
val result = (v1 + v2) * 2
println("(${result.x}, ${result.y})")

hard

A. (3, 4)

B. (4, 6)

C. (6, 8)

D. Compilation error due to operator precedence

Solution

1. Step 1: Evaluate v1 + v2

   v1 is (2,3), v2 is (1,1). Adding gives Vector(3,4).

2. Step 2: Multiply the result by 2

   Vector(3,4) times 2 gives Vector(6,8).

3. Step 3: Print the result

   Printing prints (6, 8) as expected.

4. Final Answer:

   (6, 8) -> Option C

5. Quick Check:

   (v1 + v2) * 2 = (6, 8) [OK]

Hint: Evaluate plus first, then times; operator overloading respects precedence [OK]

Common Mistakes:

• Multiplying v2 by 2 instead of the sum
• Ignoring operator precedence
• Expecting compilation error