Kotlin : 100 Interview Questions and Answers PART12

56. Purpose of the by Keyword in Kotlin

In Kotlin, the by keyword is used for delegation — allowing one object or property to delegate its implementation or behavior to another.

There are two main usages:

1. 🧱 Class Delegation

Allows a class to delegate interface implementation to another object.

Example:

interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) {
        println("LOG: $message")
    }
}

class AppLogger(private val logger: Logger) : Logger by logger

AppLogger implements Logger, but delegates the actual log() call to the ConsoleLogger instance — no need to write boilerplate.

2. 📦 Property Delegation

Lets a property delegate its getter/setter logic to another object (like lazy, observable, etc.).

Example 1: lazy

val config: String by lazy {
    println("Initializing config...")
    "ProductionConfig"
}

Example 2: observable

import kotlin.properties.Delegates

var name: String by Delegates.observable("Unknown") { _, old, new ->
    println("Name changed from $old to $new")
}

57. The concept of operator overloading in Kotlin

Operator overloading in Kotlin allows you to define custom behavior for standard operators (like +, -, *, ==, [], etc.) on your own types (classes).

Kotlin lets you "overload" predefined operators by defining functions with special names, prefixed with the operator keyword.

Example: Overloading the + Operator

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

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    val result = p1 + p2 // same as p1.plus(p2)
    println(result) // Output: Point(x=4, y=6)
}

Common Overloadable Operators in Kotlin

Example: Overloading get and set (like array access)

class Matrix {
    private val data = Array(3) { IntArray(3) }

    operator fun get(i: Int, j: Int): Int = data[i][j]
    operator fun set(i: Int, j: Int, value: Int) {
        data[i][j] = value
    }
}

val m = Matrix()
m[0, 1] = 42
println(m[0, 1]) // Output: 42

Rules & Notes

• 1. Only predefined set of operators can be overloaded.
• 2. You must use the correct function name and mark it with operator.
• 3. Operator overloading should be used judiciously—avoid making code harder to understand.

58. The purpose of the when expression in Kotlin?

The when expression in Kotlin is a powerful replacement for the switch statement (in Java or C-like languages). It allows you to match a value against multiple conditions and execute different code for each case.

Basic Syntax

val result = when (value) {
    1 -> "One"
    2 -> "Two"
    else -> "Other"
}

It can be used as:

• 1. an expression (returns a value)
• 2. a statement (performs actions)

Why use when?

• 1. Cleaner alternative to multiple if-else if
• 2. More flexible than switch (supports ranges, types, custom logic)
• 3. Works with any data type, not just numbers or enums
• 4. Can be used without an argument (like pattern matching)

Examples

1. Simple match

val x = 2
val text = when (x) {
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    else -> "Unknown"
}

2. Multiple conditions in one branch

when (x) {
    0, 1 -> println("x is 0 or 1")
    in 2..10 -> println("x is between 2 and 10")
    else -> println("x is something else")
}

3. When without argument

when {
    x % 2 == 0 -> println("Even")
    x % 2 != 0 -> println("Odd")
}

4. Type checking with is

fun printType(obj: Any) {
    when (obj) {
        is String -> println("It's a String")
        is Int -> println("It's an Int")
        else -> println("Unknown type")
    }
}

*Importants: 

59. Explain primary constructor in Kotlin.

A primary constructor is a concise way to initialize a class and its properties in Kotlin. It is defined in the class header, directly after the class name.

Syntax

class Person(val name: String, var age: Int)

This automatically:

• 1. Creates a constructor with parameters name and age
• 2. Declares and initializes properties name (read-only) and age (mutable)

Example with Primary Constructor

class User(val username: String, val email: String)

fun main() {
    val user = User("john_doe", "john@example.com")
    println(user.username)  // Output: john_doe
}

Primary Constructor with Init Block

class Product(val name: String, val price: Double) {
    init {
        println("Product created: $name costs $price")
    }
}

*Importants 

60. Primary Constructor vs Secondary Constructor