Top 30 Intermediate Mobile Dev Interview Questions and Answers

Question 1

Why does a 200ms synchronous data mapping on a React Native screen freeze interactive components like TouchableOpacity?

Accepted Answer

It monopolizes the JavaScript thread, so batched native updates and queued touch events cannot be processed.

Answer

The mapping executes on the native UI main thread, blocking rendering and touch handling for 12 frames.

Answer

The native main thread stalls waiting for the JavaScript mapping to complete before it can render updates.

Answer

React.memo cannot prevent reconciliation because the mapping creates new references, forcing expensive re-renders that exceed the 16.67ms frame budget.

Question 2

When accessing a property on a nullable object in Dart, what is the fundamental difference between using ?. and !?

Accepted Answer

?. evaluates to null when the receiver is null, while ! casts to non-nullable and may throw at runtime.

Answer

Both operators avoid runtime errors, but ?. is preferred for chained property access.

Answer

! returns null on a null receiver, whereas ?. throws a runtime null assertion error.

Answer

?. provides a default value if the object is null, while ! enforces compile-time null checks.

Question 3

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 4

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 5

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 6

When designing a Swift data model that requires independent undo snapshots without retroactive mutation, why is a struct preferred over a class?

Accepted Answer

Because assignment creates a unique copy, preventing shared references from mutating prior snapshots.

Answer

Because structs support inheritance, allowing each snapshot to override previous state behavior.

Answer

Because structs rely on ARC instead of value semantics to isolate memory between snapshots.

Answer

Because structs are always stack-allocated and therefore faster to copy for undo history.

Question 7

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 8

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 9

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 10

A class declares late final UserService repo and assigns it in initState. What happens if repo is read in build before that assignment?

Accepted Answer

A LateInitializationError is thrown at the point of access

Answer

The compiler reports a definite-assignment error before the app runs

Answer

The app crashes with a NullPointerException because null safety is bypassed

Answer

The variable behaves as nullable and returns null until assigned

Question 11

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 12

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 13

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 14

Given List<int> nums = [1, 2, 3, 4] and bool includeZero = true, which literal produces [0, 2, 4]?

Accepted Answer

[if (includeZero) 0, for (var n in nums) if (n.isEven) n]

Answer

[if (includeZero) 0, nums.where((n) => n.isEven)]

Answer

[for (var n in nums) if (n.isEven) n, if (includeZero) 0]

Answer

[if (includeZero) [0], for (var n in nums) if (n.isEven) n]

Question 15

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 16

Which statement accurately describes how Dart closures handle captured variables from an enclosing function?

Accepted Answer

They capture the variable binding by reference in a heap-allocated environment

Answer

They copy primitive variables by value and objects by reference at creation time

Answer

They keep the enclosing function's stack frame alive until the closure is destroyed

Answer

They can only be created by anonymous functions, not by named nested functions

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

In React Native, what is the default flexDirection, and how does it compare to the web?

Accepted Answer

Default is column, which differs from the web's default of row

Answer

Default is row, the same as the web's CSS default

Answer

There is no default; flexDirection must always be set explicitly

Answer

Default is row-reverse to support right-to-left languages

Question 20

For a parent View with flexDirection column, which statement about alignItems and justifyContent is correct?

Accepted Answer

justifyContent aligns children along the vertical main axis and alignItems along the horizontal cross axis

Answer

Both properties control the same axis and are interchangeable in column layouts

Answer

justifyContent centers children horizontally and alignItems centers them vertically

Answer

alignItems only affects the first child while justifyContent affects the rest

Question 21

When you set position absolute on a child View in React Native, relative to what are its top and left offsets measured?

Accepted Answer

Its nearest positioned ancestor, typically the parent View

Answer

The previous sibling element in the layout flow

Answer

The root navigation container only

Answer

The entire device screen, regardless of where the view sits in the tree

Question 22

Why does a stored closure property that references self inside its body cause a memory leak under ARC?

Accepted Answer

Because the instance holds the closure strongly while the closure captures self strongly, preventing deallocation

Answer

Because the closure is non-escaping and therefore extends the lifetime of self unexpectedly

Answer

Because ARC requires manual retain and release calls that the developer forgot to insert

Answer

Because closures are value types and copy the instance when captured

Question 23

To render a View as a perfect circle of width and height 80 with centered text, which combination is correct?

Accepted Answer

borderRadius 40 with justifyContent center and alignItems center on the parent

Answer

borderRadius 80 with only alignItems center on the parent

Answer

borderRadius 20 with textAlign center on the child only

Answer

borderRadius 40 with flexDirection row and no alignment set

Question 24

When writing a swap function in Swift, what advantage does using a generic placeholder T provide over accepting parameters of type Any?

Accepted Answer

Generics enforce that both parameters are the same concrete type and avoid runtime casting

Answer

Generics use runtime boxing to share a single machine code implementation across all types

Answer

Generics automatically convert value types to reference types during the swap

Answer

Generics allow swapping two values of unrelated types in a single function call

Question 25

Which condition justifies using [unowned self] instead of [weak self] in a Swift closure?

Accepted Answer

The closure is owned by the instance and guaranteed not to execute after deallocation

Answer

The closure escapes as an async network handler that may run after the view controller is dismissed

Answer

You want to avoid optional syntax and are uncertain whether the instance will outlive the closure

Answer

The captured reference must be zeroed at a deterministic point when the closure starts executing

Question 26

Which behavior correctly describes exception propagation for a coroutine launched with launch inside a regular Job scope?

Accepted Answer

The exception propagates to the parent, which cancels siblings and fails the scope.

Answer

The exception is deferred until the caller explicitly awaits the result.

Answer

The exception is silently swallowed if no try-catch is used inside the child.

Answer

Only the failing child is affected; siblings continue because coroutines are independent.

Question 27

Which statement accurately contrasts Dart's extends, implements, and with keywords for class reuse?

Accepted Answer

extends inherits from one superclass; implements requires reimplementing every public member; with injects behavior without subtyping.

Answer

extends allows multiple superclasses; implements reuses parent code; with establishes an is-a relationship.

Answer

extends copies only abstract methods; implements delegates to parent code; with enables multiple inheritance of state.

Answer

extends enforces contracts without code reuse; implements inherits method bodies; with requires a shared ancestor.

Question 28

In a standard CoroutineScope, if one child coroutine fails with an exception, what is the immediate effect on its siblings and the parent scope?

Accepted Answer

The failing coroutine cancels its siblings, and the exception then propagates up to cancel the parent scope.

Answer

The exception is held until the parent scope's job is explicitly joined, preventing immediate cancellation.

Answer

The failed coroutine stops, but its siblings continue to run independently within the scope.

Answer

Only the failed coroutine is cancelled; the parent scope must manually catch the exception to affect other children.

Question 29

In Kotlin's Structured Concurrency, what is the default outcome if one child coroutine launched with launch throws an uncaught exception?

Accepted Answer

The parent scope and all its sibling coroutines are immediately cancelled.

Answer

Only the failing child coroutine is cancelled, while siblings continue.

Answer

The parent automatically retries the failing child coroutine.

Answer

The exception is silently ignored, and all coroutines proceed normally.

Question 30

Which statement accurately describes a semantic difference between a Dart factory constructor and a generative constructor?

Accepted Answer

A factory constructor can return an existing cached instance or a subtype, while a generative constructor always produces a fresh instance of the exact class.

Answer

A factory constructor must be named and cannot be declared as the unnamed default constructor.

Answer

A factory constructor is invoked like a static method and does not participate in the class constructor namespace.

Answer

A factory constructor improves memory allocation performance by bypassing implicit object creation.