Kotlin : 100 Interview Questions and Answers PART3

11. Higher-order functions in Kotlin.

In Kotlin, higher-order functions are functions that either:

1. Take another function as a parameter, or
2. Return a function as a result

This is a powerful feature of Kotlin (and functional programming in general) that allows you to write more flexible and reusable code.

Example 1: Passing a function as a parameter

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// Usage
val sum = operate(5, 3) { x, y -> x + y }
val product = operate(5, 3) { x, y -> x * y }

println(sum)      // Output: 8
println(product)  // Output: 15

In this example, operate is a higher-order function that takes another function operation as a parameter.

Example 2: Returning a function

fun multiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

// Usage
val timesTwo = multiplier(2)
println(timesTwo(4))  // Output: 8

Here, multiplier returns a function that multiplies its input by factor.

Real-world use: List operations

val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
println(doubled)  // Output: [2, 4, 6, 8, 10]

Functions like map, filter, forEach, and reduce are higher-order functions that accept lambdas to operate on collections.

Benefits

• Makes code more concise and expressive
• Encourages reusability
• Enables functional programming style

Collection-Based Higher-Order Functions

Scope Functions (work on any object)

12. The use of the lateinit modifier in Kotlin

The lateinit modifier in Kotlin is used to defer the initialization of a var (mutable) non-null property when you can’t initialize it at the point of declaration but you’re sure it will be initialized before use.

Key Points of lateinit

• Only works with mutable (var) properties.
• Only for non-primitive, non-nullable types.
• Can’t be used with val, primitive types like Int, Double, or nullable types (String?).
• Mostly used in dependency injection, unit testing, and Android View Binding.

Syntax Example:

class User {
    lateinit var name: String

    fun initialize() {
        name = "Alice"
    }

    fun printName() {
        if (::name.isInitialized) {
            println(name)
        } else {
            println("Name is not initialized")
        }
    }
}

13. Comparison between lateinit and lazy initialization

Example: lateinit:

class User {
    lateinit var name: String

    fun setName(newName: String) {
        name = newName
    }

    fun printName() {
        println(name)
    }
}

Example: lazy:

val userInfo: String by lazy {
    println("Initializing...")
    "User: Alice"
}

fun main() {
    println(userInfo)  // "Initializing..." printed here, not before
}

Rule of Thumb

• Use **lateinit** when:
  •            You must initialize manually and later (e.g., Android ViewModel, Binding)
• Use **lazy** when:
  •           You want automatic, safe lazy initialization, especially for val

14. What is a data class in Kotlin?

A data class in Kotlin is a special type of class designed to hold data. It automatically provides useful methods like:

• equals() – for comparison
• hashCode() – for hash-based collections
• toString() – for readable output
• copy() – to duplicate and modify instances
• componentN() – for destructuring

Declaring a Data Class

data class User(val name: String, val age: Int)

Kotlin will auto-generate:

val user1 = User("Alice", 25)
println(user1)                      // User(name=Alice, age=25)
val user2 = user1.copy(age = 30)   // copy with updated age

🔹 Requirements for Data Classes

• Must have at least one primary constructor parameter.
• All parameters in the primary constructor must be val or var.
• Cannot be abstract, open, sealed, or inner.
•  

✅ Use Cases

• Model classes (e.g., API responses)
• DTOs (Data Transfer Objects)
• Representing UI states or configurations

15. Difference between companion objects and static members

In Kotlin, companion objects are Kotlin's alternative to Java’s static members, since Kotlin does not have a static keyword. Here’s a clear comparison:

Kotlin (Companion Object):

class MyClass {
    companion object {
        val staticLikeValue = "I am static-like"
        fun staticLikeFunction() = "Hello from Kotlin"
    }
}

val result = MyClass.staticLikeFunction()

Java (Static Members):

class MyClass {
    static String staticValue = "I am static";
    static String staticFunction() {
        return "Hello from Java";
    }
}

String result = MyClass.staticFunction();

Advanced Usage in Kotlin

• A companion object can implement interfaces or inherit from classes.
• You can name a companion object (optional).

class Factory {
    companion object Builder {
        fun create(): Factory = Factory()
    }
}

Access:

val obj = Factory.create()

Summary: