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

Following the I/O 2026 platform pivot, what architectural shift should senior engineers prioritize to avoid building obsolete Android apps?

Accepted Answer

Exposing granular business capabilities through AppFunctions and designing for agent orchestration instead of static screens

Answer

Isolating user flows within traditional intent-based screens to maintain backward compatibility

Answer

Moving all AI inference to cloud endpoints to maximize Gemini Nano 4 accuracy and reduce APK size

Answer

Migrating every screen to Compose immediately to meet the new system intelligence layer requirements

Question 3

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 4

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 5

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 6

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 7

Which migration step should teams prioritize first to reduce memory leaks when unifying Android reactive streams?

Accepted Answer

Replace unsafe lifecycle subscriptions with lifecycle-aware coroutine scopes like viewModelScope

Answer

Add explicit DROP or LATEST backpressure strategies to every Kotlin Flow collector

Answer

Convert EventBus subscribers into RxJava Observables as an incremental interim step

Answer

Map all RxJava operators to Kotlin Flow equivalents before touching subscriptions

Question 8

What is the main engineering benefit of Android CLI 1.0 reaching stable for CI/CD workflows?

Accepted Answer

It enables project scaffolding, device management, and builds to run without Android Studio on headless agents.

Answer

It ships with Stability Doctor to diagnose Compose recomposition issues in CI logs.

Answer

It introduces a framework for exposing in-app actions to AI assistants like Gemini.

Answer

It replaces Gradle as the build system for Android projects, offering faster compilation speeds.

Question 9

How does the 2026 server-driven UI approach announced at I/O fundamentally differ from traditional server-driven UI patterns?

Accepted Answer

It replaces hand-authored JSON schemas with AI-generated UI descriptions sent from the server.

Answer

It requires separate Android and iOS implementations to maintain platform-native behavior.

Answer

It eliminates the server by generating all layouts locally with on-device language models.

Answer

It renders layouts using the legacy View system instead of Jetpack Compose.

Question 10

What is the primary drawback of keeping isCoreLibraryDesugaringEnabled enabled for an app whose user base has largely migrated to API 26+ devices?

Accepted Answer

It subjects newer devices to an unnecessary runtime performance penalty via the j$ namespace shim.

Answer

It blocks the app from receiving modular system updates pushed by Google Play.

Answer

It causes the APK to bundle duplicate native kernel hooks for every architecture.

Answer

It prevents the D8 compiler from rewriting lambda expressions into compatible bytecode.

Question 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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 21

When a native module method reads a live device value to return to JavaScript, why should it use a Promise or callback rather than a direct return?

Accepted Answer

Because crossing the native-to-JS boundary is asynchronous, so results are delivered via promise or callback

Answer

Because Promises are required to register the module in the package list

Answer

Because native code cannot return primitive values to JavaScript at all

Answer

Because synchronous returns are blocked by the Metro bundler

Question 22

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 23

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 24

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 25

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 26

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 27

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 28

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 29

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 30

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.