Top Interview Questions for Kotlin Mobile App Developers | AI-Guided Insight

Higher-order functions are functions that either take other functions as parameters or return a function as a result. This feature allows for more flexible and reusable code by abstracting common patterns of behavior.

In Kotlin, functions are treated as first-class citizens, meaning you can assign them to variables, pass them as arguments, and return them from other functions.

Example of a higher-order function:

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

// Usage
val sum = calculate(5, 3, { a, b -> a + b })

Here, calculate is a higher-order function that takes another function operation as a parameter and applies it to x and y .

Higher-order functions differ from regular functions in that regular functions do not accept other functions as parameters or return them as results.

These are scope functions in Kotlin that help to perform operations on objects in a concise and readable way. Each has a different purpose and use case:

• let : Used to perform actions on a non-null object, often used to handle nullable types. It returns the result of the lambda expression.

val name: String? = "Ashna"
name?.let {
    println(it)
}

• apply : Used to configure an object. It returns the object itself, allowing for chaining of calls.

val person = Person().apply {
    name = "Ashna"
    age = 25
}

• run : Used to execute a block of code with a receiver object and return the result of the last expression in the block.

val result = person.run {
    age + 5
}

• also : Used to perform additional operations on an object. It returns the object itself, similar to apply , but with a focus on side effects.

val person = Person().also {
    it.name = "Ashna"
}

• with : Used to call multiple methods on the same object without repeating its name. It is not an extension function, unlike the others.

val result = with(person) {
    name = "Ashna"
    age = 25
    age + 5
}

Kotlin allows you to define default values for function parameters, which makes function calls more flexible and reduces the need for overloaded methods.

Default Arguments: You can specify default values for parameters in the function declaration. If the caller doesn’t provide an argument, the default value is used.

fun greet(name: String = "Guest") {
    println("Hello, $name!")
}
greet() // Prints: Hello, Guest!
greet("Ashna") // Prints: Hello, Ashna!

Named Arguments: Named arguments allow you to specify the arguments by their parameter names, which improves readability, especially when a function has many parameters or some of them are optional.

fun printDetails(name: String, age: Int = 18, city: String = "Unknown") {
    println("Name: $name, Age: $age, City: $city")
}
printDetails(name = "Ashna", city = "Delhi") // Age will use the default value

Named arguments can also be used to skip parameters with default values, providing only the necessary arguments.

These keywords control inheritance and method/property behavior in Kotlin:

• open: By default, all classes and methods in Kotlin are final, meaning they cannot be inherited or overridden. The open keyword allows a class or method to be inherited or overridden.

open class BaseClass {
    open fun display() {
        println("BaseClass Display")
    }
}

• final: This is the default modifier in Kotlin and indicates that a class or method cannot be inherited or overridden. It’s explicitly used to prevent overriding in a subclass.

open class BaseClass {
    final fun display() {
        println("BaseClass Display")
    }
}

• abstract: Used to define abstract classes and methods that must be implemented by subclasses. An abstract method doesn’t have a body.

abstract class AbstractClass {
    abstract fun draw()
}

• override: Used to override a method in a subclass. The method in the base class must be marked with the open keyword.

class DerivedClass : BaseClass() {
    override fun display() {
        println("DerivedClass Display")
    }
}

Coroutines in Kotlin are a way to handle asynchronous programming efficiently and with less boilerplate code. They are a type of lightweight thread that allows for non-blocking, concurrent operations.

Key Benefits of Coroutines:

• Lightweight: Coroutines are much more memory-efficient than traditional threads, allowing you to create thousands of coroutines without significant performance overhead.
• Structured Concurrency: Coroutines provide a structured way to manage asynchronous code, ensuring that tasks are completed or cancelled together, avoiding potential leaks.
• Non-blocking: Coroutines are non-blocking, which means they don’t block the main thread. Instead, they suspend execution and resume when the operation is complete.

Example of a coroutine:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("Coroutine!")
    }
    println("Hello,")
}

This code prints "Hello," and then, after a one-second delay, prints "Coroutine!"—all without blocking the main thread.

Sealed classes in Kotlin are used to represent restricted class hierarchies, where a value can have one of a limited set of types. Sealed classes are particularly useful when you want to model algebraic data types or when you need exhaustive when expressions.

A sealed class is abstract by nature, and its subclasses must be defined within the same file. This ensures that all possible subclasses are known at compile-time, making when expressions exhaustive without the need for an else branch.

Example:

sealed class Result {
    class Success(val data: String) : Result()
    class Error(val exception: Exception) : Result()
}

fun handleResult(result: Result) {
    when(result) {
        is Result.Success -> println("Data: ${result.data}")
        is Result.Error -> println("Error: ${result.exception.message}")
    }
}

In this example, the when expression covers all possible subclasses of the Result sealed class, ensuring safe and clear handling of different outcomes.

Kotlin provides two main ways to perform type casting: safe casts and explicit casts.

• Safe Casts ( as? ): This operator attempts to cast a variable to a given type and returns null if the cast is not possible.

val obj: Any? = "Hello"
val str: String? = obj as? String // Safe cast

• Explicit Casts ( as ): This operator casts a variable to a given type, but throws a ClassCastException if the cast is not possible.

val obj: Any = "Hello"
val str: String = obj as String // Explicit cast

• Smart Casts: Kotlin's smart casts allow the compiler to automatically cast a variable to a specific type after a type check using is . If a variable is checked with is and the check is successful, the compiler automatically casts the variable to the desired type, eliminating the need for explicit casting.

fun printLength(obj: Any) {
    if (obj is String) {
        println(obj.length) // Smart cast to String
    }
}

Here, after checking obj is String , obj is automatically cast to String within the if block.

Inline functions in Kotlin are functions that are expanded at the call site during compilation, rather than being invoked in the traditional way. The inline keyword is used to declare an inline function.

Advantages of Inline Functions:

• Performance Improvement: By inlining a function, you eliminate the overhead associated with a function call, which can improve performance, especially in tight loops or recursive calls.
• Avoiding Lambda Capturing: Inline functions are particularly useful when passing lambda expressions as parameters because they avoid the creation of additional objects (like function objects) and help in reducing memory overhead.

Example:

inline fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

In this example, the performOperation function is inlined, meaning the lambda expression passed to it is directly inserted into the calling code.

Use Case: You would use inline functions in performance-critical sections of your code or when working with higher-order functions that take lambdas, to avoid unnecessary memory allocations.

Kotlin handles exceptions similarly to Java, but with some key differences, particularly in how exceptions are categorized.

• Try-Catch Block: Kotlin uses the traditional try-catch-finally block to handle exceptions.

try {
    // Code that might throw an exception
} catch (e: Exception) {
    // Handle exception
} finally {
    // Optional: Code that will always run
}

• Checked vs. Unchecked Exceptions: In Kotlin, all exceptions are unchecked, meaning that the compiler does not force you to catch or declare exceptions. This contrasts with Java, where you must either catch or declare checked exceptions.

fun riskyOperation() {
    throw Exception("An error occurred")
}

fun main() {
    riskyOperation() // No need to declare or catch the exception
}

The lack of checked exceptions in Kotlin is a design choice that simplifies error handling, as it avoids cluttering code with boilerplate throws declarations and encourages more meaningful error management strategies.

The by keyword in Kotlin is used for delegation, a design pattern that allows an object to delegate part of its behavior to another object.

Property Delegation: Kotlin provides a way to delegate the getter and setter of a property to another object, using the by keyword. Commonly used delegates are lazy , observable , and vetoable .

val lazyValue: String by lazy {
    println("Computed!")
    "Hello"
}

In this example, the lazy delegate ensures that the lazyValue is computed only once when it is first accessed.

Class Delegation: Kotlin allows you to delegate the implementation of an interface to another object. This is particularly useful for composition over inheritance.

interface Base {
    fun printMessage()
}

class BaseImpl(val x: Int) : Base {
    override fun printMessage() { println(x) }
}

class Derived(b: Base) : Base by b

In this example, the Derived class delegates the printMessage method to the instance of Base provided.

Use Case: Delegation is useful when you want to reuse functionality from another class without using inheritance, thus promoting composition.

In Kotlin, == and === are used for different types of comparisons:

• == (Structural Equality): This operator checks for structural equality, meaning it compares the contents of two objects to see if they are equal. Internally, it calls the equals() method.

val a = "Kotlin"
val b = "Kotlin"
println(a == b) // true

In this example, a == b evaluates to true because the contents of a and b are the same.

• === (Referential Equality): This operator checks for referential equality, meaning it checks whether two references point to the same object in memory.

val a = "Kotlin"
val b = a
println(a === b) // true

In this case, a === b is true because both a and b refer to the same object in memory. However, if b was created as a separate instance with the same value, a === b would be false .

Use Case:

• Use == when you need to compare the contents of two objects.
• Use === when you need to check if two references point to the same object.

Inline classes in Kotlin are a way to create a wrapper around a value type without the overhead of allocating additional memory. Inline classes are used to add type safety or domain-specific meaning to primitive types without runtime overhead.

To define an inline class, use the inline keyword followed by the value keyword:

inline class UserId(val id: Int)

Benefits of Inline Classes:

• No Runtime Overhead: The inline class is replaced with the underlying type at runtime, meaning it has no memory overhead.
• Type Safety: Inline classes add type safety, preventing accidental misuse of types.
• Enhanced Semantics: They help to give domain-specific meaning to otherwise primitive types.

Example:

inline class Password(val value: String)
fun validate(password: Password) {
    // Use the password value
}

In this example, the Password inline class adds meaning to the String type, ensuring that only valid passwords are passed to the validate function.

Use Case: Use inline classes when you need lightweight type wrappers that provide additional type safety or meaning without the overhead of traditional classes.

Extension functions in Kotlin allow you to add new functionality to existing classes without modifying their source code. This is done by defining a function outside of the class, and it can be called as if it were a member function of that class.

Syntax: An extension function is declared by prefixing the function name with the type you want to extend.

fun String.addExclamation(): String {
    return this + "!"
}

In this example, the String class is extended with a new function addExclamation , which adds an exclamation mark to the end of the string.

Usage:

val greeting = "Hello"
println(greeting.addExclamation()) // Prints: Hello!

Use Case: Extension functions are useful when you need to add utility functions to classes you don’t own (like classes from libraries or the standard library), or when you want to keep your code organized by adding specific functionality without modifying existing code.

Kotlin treats generic types as nullable by default, meaning a generic type parameter can accept both nullable and non-nullable types unless explicitly specified otherwise.

For example:

class Box(val value: T)

In this example, T can be of any type, including nullable types:

val boxOfString = Box("Hello") // Box
val boxOfNullableString = Box(null) // Box

Use Case: If you want to restrict the generic type to only non-nullable types, you can use T : Any as a type bound:

class Box(val value: T)

Here, T is restricted to non-nullable types only.

This approach ensures type safety and prevents accidental null assignment to generic types where nullability is not intended.

The lateinit keyword in Kotlin is used to declare a non-nullable property that will be initialized later, typically after the object is constructed. It is only applicable to var properties and not to val .

Key Features of lateinit :

• Non-nullable: The property must be non-nullable.
• Deferred Initialization: It allows for deferred initialization, which is useful when dependency injection or initialization in a lifecycle method (like onCreate in Android) is required.
• Checking Initialization: You can check whether a lateinit property has been initialized using the ::propertyName.isInitialized syntax.

Example:

class MyClass {
    lateinit var name: String

    fun initializeName() {
        name = "Ashna"
    }

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

Use Case: Use lateinit when you need a non-nullable property that cannot be initialized during object construction, but will be initialized before it is accessed.