Top 30 Android & 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

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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.

Question 21

When modeling a closed set of UI states where Loading needs no data, Success carries a User, and Error carries a String, why is a sealed class preferable to an enum?

Accepted Answer

Enum constants share a single constructor signature, making it awkward to attach different data to each state, whereas sealed subclasses can define their own parameters

Answer

Enums cannot implement interfaces or hold properties, limiting them to simple constant values

Answer

A plain data class hierarchy solves the same problem more simply, since sealed classes add unnecessary restrictions on inheritance

Answer

Sealed classes guarantee that when expressions do not need an else branch, while enum-based when expressions always require one

Question 22

You must convert a nullable `user` into a `Session`, logging the user's ID first. Which implementation is the most idiomatic and correct for the function body?

Accepted Answer

return user?.let { log(it.id); Session(it) }

Answer

user?.let { log(it.id) }; return Session(user!!)

Answer

return user?.apply { log(this.id); Session(this) }

Answer

if (user != null) { log(user.id); return Session(user) } else { return null }

Question 23

Given val result = name?.apply { trim().length } where name is String?, what is the inferred type of result and why?

Accepted Answer

String? because apply always returns the original receiver object, ignoring the lambda's final value

Answer

Unit because apply is intended for configuration and does not propagate lambda results

Answer

Int? because the lambda's last expression is an Int and the safe call preserves nullability

Answer

String because the safe call on a non-null execution path eliminates the nullability of the returned receiver

Question 24

Which Kotlin scope function is most idiomatic for configuring an object's properties and then returning the configured object itself?

Accepted Answer

apply

Answer

also

Answer

run

Answer

let

Question 25

What is the fundamental reason `reified` type parameters can only be used with `inline` functions in Kotlin?

Accepted Answer

inline allows the compiler to substitute the concrete type argument for the generic parameter directly into the bytecode at the call site, bypassing JVM type erasure.

Answer

inline functions guarantee that the generic type parameter is always known at compile-time, which reified then uses to generate specific type-safe bytecode.

Answer

inline functions prevent the creation of lambda objects, which would otherwise block reified from accessing type information.

Answer

reified types require the performance benefits of inline to efficiently perform type checks at runtime without significant overhead.

Question 26

Why must a Kotlin function be declared `inline` to use a `reified` type parameter?

Accepted Answer

Because inlining moves the function's bytecode to the call site, where the compiler can access the concrete type argument.

Answer

To ensure the function call avoids creating a lambda object, which would otherwise interfere with runtime type checks.

Answer

Because `reified` checks are computationally expensive and require the performance optimizations that `inline` provides.

Answer

To prevent the JVM's type erasure from removing the generic type information from the function's signature in the compiled class file.

Question 27

Why does a reified type parameter require the enclosing function to be marked inline?

Accepted Answer

Because inlining copies the body to the call site so the compiler can substitute the concrete type into bytecode despite JVM erasure.

Answer

Because reified parameters implicitly create a Class reference, which inline functions can pass without allocation overhead.

Answer

Because the JVM preserves generic type information only for methods flagged as inline by the Kotlin compiler.

Answer

Because inline functions execute faster, and reified type checks would otherwise be too slow at runtime.

Question 28

When running a background task that might fail, how do you defer exception handling until the result is actually needed?

Accepted Answer

Use `async` and wrap the call to `await()` in a `try-catch` block.

Answer

Use `async` and avoid calling `await()` to suppress the exception.

Answer

Use `launch` with a `CoroutineExceptionHandler` to catch the error.

Answer

Use `launch` and wrap the call to `join()` in a `try-catch` block.

Question 29

For a Kotlin Coroutine task that updates a UI element and does not require a return value, which builder is most appropriate?

Accepted Answer

launch

Answer

runBlocking

Answer

withContext

Answer

async

Question 30

You need to fetch two pieces of data in parallel inside a ViewModel and return both results to the caller. Which choice best follows structured concurrency?

Accepted Answer

Use async for both calls and await each Deferred before returning

Answer

Use launch for both calls and assign the results to global variables

Answer

Use async with a custom Job to prevent cancellation from the ViewModel scope

Answer

Use launch because async coroutines are not children of the calling scope