Top 30 Kotlin Interview Questions and Answers

Question 1

In Kotlin, what does declaring a variable with val guarantee about the referenced object?

Accepted Answer

The reference cannot be reassigned, though the object's contents may still mutate

Answer

All properties of the object are automatically converted to read-only

Answer

The object becomes deeply immutable and thread-safe by default

Answer

The compiler prevents any modification to the object's internal state

Question 2

A developer needs to store a user's current score in a game, which will change throughout gameplay. Which Kotlin keyword should be used?

Accepted Answer

var

Answer

let

Answer

val

Answer

const

Question 3

When adding a new implicit dependency such as a Logger to a deep call chain, what is the main benefit of Kotlin 2.4.0 stable context parameters?

Accepted Answer

They let the compiler pass the dependency implicitly through the call stack, avoiding changes to every intermediate function signature.

Answer

They compile the dependency directly into Java 26 bytecode to improve runtime performance.

Answer

They expose the dependency as a public property while storing it in a differently typed private backing field.

Answer

They generate a platform-independent UUID to identify the dependency instance across JVM, Native, and JS targets.

Question 4

What is the main advantage of Kotlin's approach to null safety with default non-nullable types?

Accepted Answer

It shifts the detection of potential NullPointerExceptions from runtime to compile time.

Answer

It allows the !! operator to be used safely in all situations.

Answer

It guarantees that all val variables are compile-time constants.

Answer

It simplifies code by eliminating the need for any null checks.

Question 5

Given the Kotlin declaration `val userNames = mutableListOf("Alice")`, which statement accurately describes the `userNames` variable?

Accepted Answer

The variable `userNames` cannot be reassigned, but the list it points to can be modified.

Answer

The code fails to compile because a `val` cannot reference a mutable object.

Answer

The list is completely immutable; no new users can be added or removed.

Answer

The variable `userNames` can be reassigned to a new list, as long as the new list is not null.

Question 6

When migrating to Koog 1.0, how should teams handle the stable and beta module split to align with JetBrains' support guarantees?

Accepted Answer

Move core dependencies to stable modules while isolating beta features to specific use cases

Answer

Adopt beta modules for core agent logic and stable modules for peripheral utilities

Answer

Migrate all code to stable modules and defer beta features until they mature

Answer

Keep all modules on the beta channel to lock in the one-year API guarantee

Question 7

How do the Kotlin Language Server Alpha and the Kotlin Toolchain differ in purpose?

Accepted Answer

The Language Server brings IntelliJ-engine-backed completions to LSP editors, while the Toolchain unifies build, test, and agent workflows

Answer

The Language Server generates kdoc.jar documentation for AI agents, while the Toolchain handles code formatting

Answer

The Language Server is a unified CLI for building and testing, while the Toolchain provides editor diagnostics

Answer

The Language Server stabilizes context parameters, while the Toolchain introduces explicit backing fields

Question 8

What is the main benefit of Swift package support in Kotlin/Native for multiplatform teams?

Accepted Answer

It lets teams consume Apple ecosystem dependencies directly instead of maintaining bridging wrappers or CocoaPods workarounds.

Answer

It removes the requirement for a macOS host when building Apple-targeted Kotlin code.

Answer

It forces migration from CocoaPods to Swift Package Manager for all iOS dependencies.

Answer

It automatically exports every Kotlin public API to Swift without requiring annotations.

Question 9

If user is null, what happens when evaluating user?.name ?: "Guest"?

Accepted Answer

It returns Guest without throwing an exception

Answer

It throws a NullPointerException because safe calls crash on null receivers

Answer

It returns null because the safe call preserves the nullable type

Answer

It requires an explicit null check to compile safely

Question 10

Given a nullable `user: User?`, how do you safely get its name's length, returning 0 if either `user` or its `name` property is null?

Accepted Answer

user?.name?.length ?: 0

Answer

user?.name?.length

Answer

user!!.name!!.length

Answer

if (user != null && user.name != null) user.name.length else 0

Question 11

Given `data class User(val name: String?)` and a nullable `val activeUser: User?`, which Kotlin expression correctly retrieves the user's name, providing "Guest" if `activeUser` is null or its `name` property is null?

Accepted Answer

activeUser?.name ?: "Guest"

Answer

activeUser!!.name ?: "Guest"

Answer

activeUser.name ?: "Guest"

Answer

if (activeUser != null && activeUser.name != null) activeUser.name else "Guest"

Question 12

What is the main consequence of using the not-null assertion operator (!!) in Kotlin?

Accepted Answer

It tells the compiler to trust that a value is not null, potentially leading to a runtime NullPointerException if it is.

Answer

It automatically converts a nullable type into its non-nullable equivalent without any risk.

Answer

It safely calls a method or accesses a property on a nullable object, returning null if the object itself is null.

Answer

It provides a default value if the expression on its left side evaluates to null.

Question 13

What is a mandatory requirement when using an `if` expression to assign a value to a variable in Kotlin?

Accepted Answer

An `else` branch must always be present to cover all possible outcomes.

Answer

The variable must be declared as `var` to allow reassignment.

Answer

Every branch within the `if` expression must explicitly use the `return` keyword.

Answer

Each branch of the `if` expression can only contain a single statement.

Question 14

If a class has a member function and an extension function is defined with the same signature, which one will be invoked when called on an instance of that class?

Accepted Answer

The member function, because member functions always take precedence.

Answer

The extension function, as it is resolved statically at the call site.

Answer

Whichever function is brought into scope last via an import statement.

Answer

A compile-time error will occur due to the ambiguous call.

Question 15

Which statement accurately describes the underlying mechanism of Kotlin extension functions?

Accepted Answer

They are compiled into static utility methods where the receiver object is passed as the first parameter.

Answer

They modify the original class's bytecode to inject new methods at runtime.

Answer

They provide a mechanism for dynamic method dispatch, allowing custom implementations to override existing class methods.

Answer

They enable a form of compile-time inheritance, allowing a class to implicitly extend another's functionality.

Question 16

Which statement accurately describes how Kotlin resolves an extension function call on a receiver?

Accepted Answer

It uses the compile-time declared type of the receiver, compiling down to a static method call

Answer

It requires the receiver class to be open or the extension to be marked override to function

Answer

It inserts the function directly into the receiver class bytecode as a new instance method

Answer

It uses the runtime type of the receiver to choose among extension overloads, similar to virtual methods

Question 17

What is the main purpose of using functions in Kotlin?

Accepted Answer

To package reusable logic, preventing code duplication and enhancing structure.

Answer

To define variables that can be modified from anywhere in the program.

Answer

To allow parameters to be mutable by default within their scope.

Answer

To automatically optimize code execution speed during compilation.

Question 18

When working with immutable state in Kotlin, which generated function of a data class is specifically designed to create a new object instance with modified properties without altering the original?

Accepted Answer

copy()

Answer

toString()

Answer

hashCode()

Answer

equals()

Question 19

When managing immutable state with a data class, what is the primary role of the generated `copy()` function?

Accepted Answer

To create a new, modified instance of the object, leaving the original unchanged.

Answer

To efficiently modify the properties of the original state object in place.

Answer

To generate a readable string representation of the object's properties for logging and debugging.

Answer

To create a complete, deep copy of the object, including new instances of any nested objects.

Question 20

When using a Kotlin data class as a key in a HashMap, which statement about its compiler-generated behavior is true?

Accepted Answer

Only properties defined in the primary constructor marked as val or var are used in generated equals and hashCode, so the key remains consistent in the map.

Answer

Calling copy creates a deep clone of the instance, recursively copying nested objects to prevent shared mutable state.

Answer

The generated equals and hashCode include both primary constructor parameters and properties declared in the class body to ensure complete structural equality.

Answer

A data class can be marked open to allow inheritance while the compiler still generates the standard five functions for subclasses.

Question 21

What is the primary reason Kotlin classes are final by default?

Accepted Answer

To encourage explicit design for inheritance and promote composition over inheritance.

Answer

To optimize runtime performance by allowing the compiler to inline method calls more aggressively.

Answer

To ensure that all class properties are immutable unless explicitly marked as mutable.

Answer

To prevent developers from creating circular dependencies in class hierarchies.

Question 22

An Android Fragment needs a property for a complex, computationally expensive object that is only used in certain user flows. The object should be created only once. Which declaration is most appropriate?

Accepted Answer

private val myObject: MyObject by lazy { createExpensiveObject() }

Answer

private lateinit val myObject: MyObject

Answer

private lateinit var myObject: MyObject

Answer

private var myObject: MyObject? = null

Question 23

Which statement accurately describes a fundamental difference between lateinit var and val by lazy in Kotlin?

Accepted Answer

val by lazy can initialize properties of any type, including primitives, unlike lateinit var.

Answer

lateinit var guarantees initialization only when first accessed, preventing unnecessary object creation.

Answer

val by lazy requires explicit thread synchronization if accessed from multiple threads, whereas lateinit var handles it automatically.

Answer

lateinit var is used for immutable properties, while val by lazy is for mutable ones.

Question 24

In an Activity, a property holds a ViewModel obtained via ViewModelProvider in onCreate. Why is lateinit var more suitable than val by lazy?

Accepted Answer

lateinit var allows imperative assignment and can be reassigned if the Activity is recreated

Answer

lateinit var works with primitive types and immutable declarations

Answer

lateinit var is thread-safe by default while lazy is not

Answer

lateinit var defers initialization until first access and caches the result

Question 25

Which statement accurately describes the behavior of the copy() method generated for a Kotlin data class?

Accepted Answer

It performs a shallow copy, meaning references to mutable objects within the data class are shared between the original and the new instance.

Answer

It creates a new instance where all properties, including nested mutable objects, are deep copied.

Answer

It is primarily used for destructuring declarations, not for creating new instances.

Answer

It only copies properties that are explicitly marked as val in the primary constructor.

Question 26

What core characteristic of Kotlin's function handling makes higher-order functions possible?

Accepted Answer

The treatment of functions as first-class citizens, allowing them to be passed as arguments or returned.

Answer

The ability to define functions as members of classes, promoting encapsulation.

Answer

Its robust type inference system, simplifying function signature declarations.

Answer

Its support for coroutines, enabling asynchronous function execution.

Question 27

In Kotlin, what is the defining characteristic that makes a function a 'higher-order function'?

Accepted Answer

It accepts a function as an argument or returns a function as its result.

Answer

It must be defined using a lambda expression or an anonymous function.

Answer

It calls at least one other function within its body to complete its task.

Answer

It operates on a collection of items, like a List or Map, to produce a new collection.

Question 28

What distinguishes filterAndTransform as a higher-order function rather than merely a generic function in Kotlin?

Accepted Answer

It takes other functions as arguments, such as predicate and transform

Answer

It chains standard library collection operators like filter and map

Answer

It returns a newly created list instead of mutating the original

Answer

It declares type parameters to accept lists of any element type

Question 29

To model a state machine where each state might carry unique, type-specific data (e.g., a success state holding a user object, an error state holding a message), which Kotlin construct is most appropriate?

Accepted Answer

A sealed class

Answer

An enum class

Answer

An interface

Answer

An abstract class with a private constructor

Question 30

To model a network request's state—`Loading`, `Success` (with data), or `Error` (with a message)—which Kotlin construct is most suitable?

Accepted Answer

A sealed class, because each of its subclasses can carry different data types specific to that state.

Answer

An enum, because it represents a fixed set of constants, which is what these states are.

Answer

A sealed interface, because it provides maximum flexibility if the states need to inherit from other classes.

Answer

An enum with nullable properties for both data and an error message to accommodate all states.