Kotlin MCQ

Explanation

Kotlin was developed by JetBrains and first released in 2011. It became an official language for Android development in 2017.

Explanation

val declares a read-only (immutable) reference. var declares a mutable variable that can be reassigned.

Explanation

Appending ? to a type (e.g., String?) marks it as nullable, allowing null values. Without ?, Kotlin types are non-nullable by default.

Explanation

The Elvis operator (val result = a ?: b) returns a if it's not null, otherwise returns b.

Explanation

Data classes (data class Person(val name: String)) are designed to hold data and auto-generate boilerplate methods.

Explanation

Kotlin uses the fun keyword to declare functions.

Explanation

object MyObject { } declares a singleton in Kotlin — only one instance exists, created lazily on first access.

Explanation

str?.length returns null if str is null rather than throwing a NullPointerException.

Explanation

companion object acts like static members in Java, accessible via the class name, e.g., MyClass.create().

Explanation

Sealed classes restrict the class hierarchy to a known set of subclasses, enabling exhaustive when expressions.

Explanation

Kotlin allows declaring the primary constructor directly in the class header with optional val/var to create properties.

Explanation

"Hello, $name!" or "${user.fullName}" embeds variable values or expressions directly in string literals.

Explanation

In Kotlin, == is the safe structural equality (null-safe equals()), while === checks if two references point to the same object.

Explanation

Kotlin uses as for unsafe casting and as? for safe casting (returns null instead of throwing on failure).

Explanation

Kotlin lambdas are written as { x: Int -> x * 2 }. If there's a single parameter, you can use the implicit it.

Explanation

when replaces Java's switch and is more powerful — it can match ranges, types, and expressions, and can be used as a statement or expression.

Explanation

Unit corresponds to Java's void. Functions that return nothing return Unit, which can be omitted from the function signature.

Explanation

Kotlin uses the interface keyword. Unlike Java, Kotlin interfaces can have property declarations and default implementations.

Explanation

fun String.shout() = uppercase() + "!" adds a shout() method to String without subclassing or modifying String.

Explanation

value!! asserts the value is non-null. If it is null, a KotlinNullPointerException is thrown. Use sparingly.

Explanation

Kotlin doesn't have static. You can use companion object functions (class-level) or top-level functions (package-level) as alternatives.

Explanation

Kotlin distinguishes read-only (List) from mutable (MutableList) collection interfaces, promoting immutability by default.

Explanation

init blocks run in declaration order as part of primary constructor execution, useful for validation or complex initialization.

Explanation

Kotlin supports default parameter values directly in the function signature, reducing the need for overloads.

Explanation

enum class Direction { NORTH, SOUTH, EAST, WEST } creates named constants. Enum classes can have properties and methods.

Explanation

In Kotlin, classes and members are final by default. The open modifier allows them to be subclassed or overridden.

Explanation

let is often used for null-safe chaining: nullableObj?.let { doSomethingWith(it) }. It returns the lambda result.

Explanation

apply executes a lambda where this refers to the receiver and returns the receiver itself, ideal for object initialization.

Explanation

Higher-order functions treat functions as first-class citizens. Examples include map, filter, and reduce from the standard library.

Explanation

map applies a transformation lambda to each element and returns a new list of results.

Explanation

Kotlin's type system distinguishes nullable (String?) from non-nullable (String) at compile time, catching most NullPointerExceptions before runtime.

Explanation

Kotlin properties replace Java fields + getter/setter patterns. You can customize access with get() and set(value) blocks.

Explanation

@JvmStatic on a companion object function generates a static method in the class bytecode for seamless Java interoperability.

Explanation

Functions returning Nothing always throw an exception or loop forever. It is a subtype of all types, useful for throw expressions in when branches.

Explanation

After if (x is String) { ... }, x is automatically treated as String inside the block — no explicit cast needed.

Explanation

1..10 creates an IntRange from 1 to 10 inclusive, usable in for loops and in checks.

Explanation

var allows reassignment; val doesn't. Note that val only prevents reference reassignment — a mutable object held by val can still be mutated.

Explanation

Kotlin uses for (item in collection) for iteration, similar to Java's enhanced for loop.

Explanation

also is like apply but uses it instead of this, and returns the receiver. Useful for side-effects like logging.

Explanation

@Suppress("UNCHECKED_CAST") tells the compiler to silence a specific warning for the annotated element.

Explanation

Pair<A, B> is a data class with first and second properties. You can create one with Pair(a, b) or the infix to function: a to b.

Explanation

Coroutines are Kotlin's mechanism for asynchronous and concurrent programming. They are cheap, can suspend at suspension points, and resume later without blocking.

Explanation

The suspend modifier allows a function to use suspension points (like delay or await). The compiler transforms it into a state machine.

Explanation

launch is for fire-and-forget coroutines. async is for coroutines that produce a result accessed via Deferred.await().

Explanation

Inline functions copy their body (and the lambda bodies) to each call site at compile time, eliminating the overhead of lambda object creation and virtual dispatch.

Explanation

Normally, generics are erased at runtime. reified (only in inline functions) preserves the type, allowing inline fun <reified T> isOf(value: Any) = value is T.

Explanation

class Derived(base: Base) : Base by base delegates all Base method calls to base. Property delegation (val x by Delegate()) customizes get/set.

Explanation

val heavy by lazy { expensiveComputation() } only runs expensiveComputation() on the first access, caching the result for subsequent reads.

Explanation

withContext suspends the current coroutine, switches to the specified dispatcher, executes the block, then resumes on the original dispatcher.

Explanation

Flow<T> is a cold stream — it starts emitting only when collected. It supports operators like map, filter, and flatMap for reactive-style programming.

Explanation

StateFlow is like LiveData — it always has a value and emits updates. SharedFlow is more flexible with configurable replay, buffer, and overflow strategies.

Explanation

Structured concurrency (via CoroutineScope) ensures coroutines don't leak: if a scope is cancelled, all its children are cancelled too.

Explanation

operator fun plus(other: MyType) enables using + with your custom class.

Explanation

val (name, age) = person unpacks the data class via component1(), component2() functions. Works for data classes, Pairs, and Map entries.

Explanation

crossinline is needed when a lambda is invoked in a different execution context (e.g., inside another lambda) where non-local returns would be unsafe.

Explanation

An object declaration creates a singleton — one instance is created lazily and shared globally. A class is a blueprint for creating multiple instances.

Explanation

val x = 42 infers Int. val list = listOf("a") infers List<String>. The compiler analyzes the expression to determine the type.

Explanation

typealias StringList = List<String> creates an alias. Useful for shortening complex generic types but does not provide type safety.

Explanation

@JvmInline value class Email(val value: String) gives type safety (Email vs String) but is represented as String in JVM bytecode, avoiding boxing.

Explanation

Contracts (kotlin.contracts) let functions declare guarantees (e.g., "if this returns true, parameter x is not null") so the compiler can perform better smart casts.

Explanation

fun sum(vararg numbers: Int) allows calling sum(1, 2, 3). Inside the function, numbers is an IntArray.

Explanation

If fun f(vararg xs: Int) and vals arr = intArrayOf(1, 2), call f(*arr) to unpack the array as individual arguments.

Explanation

Kotlin has no checked exceptions. try-catch is used but not enforced by the compiler. runCatching is a functional alternative returning Result.

Explanation

run executes a lambda where this refers to the receiver and returns the lambda's result. It is useful for object initialization combined with computation.

Explanation

With a regular Job, a failing child cancels the parent and all siblings. SupervisorJob isolates failures so only the failed child is cancelled.

Explanation

Channel<T> is like a BlockingQueue but non-blocking. Coroutines use send() to produce and receive() to consume, supporting producer-consumer patterns.

Explanation

class MyClass : InterfaceA, InterfaceB, ParentClass() implements multiple interfaces and optionally extends one class.

Explanation

Dispatchers.Main is the UI dispatcher. Dispatchers.IO has a large thread pool (default 64) designed for blocking I/O like network or disk operations.

Explanation

flow.catch { e -> emit(defaultValue) } handles exceptions from upstream operators. It does not catch exceptions in downstream operators.

Explanation

combine(flow1, flow2) { a, b -> a + b } re-evaluates the transform whenever either flow1 or flow2 emits. Useful for reactive UI state combination.

Explanation

flatMapConcat waits for each inner flow to complete before starting the next. flatMapMerge starts all inner flows concurrently (default concurrency = 16).

Explanation

LazyThreadSafetyMode.NONE removes synchronization overhead. Use when you are certain the property will only be accessed from one thread.

Explanation

html { body { p { +"Hello" } } } uses type-safe builders. Each function accepts a receiver lambda, scoping available methods to the context object.

Explanation

with(textView) { text = "Hello"; textSize = 16f } is useful when calling multiple methods on the same non-nullable object.

Explanation

coroutineScope propagates child failures. supervisorScope (like SupervisorJob) isolates failures — useful when parallel tasks are independent.

Explanation

@Volatile var flag = false ensures reads/writes go directly to main memory, making state changes visible across threads immediately.

Explanation

@Synchronized fun update() compiles to a synchronized method on the JVM, acquiring the monitor lock on the object before entering.

Explanation

Kotlin's Array maps directly to Java arrays. List/MutableList are Kotlin interfaces with richer API. Prefer List unless interop or performance requires Array.

Explanation

buildString { append("Hello, "); append(name); append("!") } is equivalent to StringBuilder().apply { ... }.toString() but cleaner.

Explanation

CoroutineExceptionHandler { _, exception -> log(exception) } is set as context: launch(handler) { }. It only handles exceptions from launch, not async (which stores them in Deferred).

Explanation

@JvmInline value class Email(val value: String) creates a type distinct from String — passing a String where Email is expected is a compile error, unlike a type alias.

Explanation

The Kotlin compiler desugars suspend functions into state machines with a Continuation<T> parameter. Each suspension point becomes a state; the continuation is resumed when the result is available.

Explanation

CPS transformation adds an implicit Continuation<T> to every suspend function. The state machine calls continuation.resumeWith(result) when the async operation completes.

Explanation

Regular flow {} is cold — it starts fresh for each collector. StateFlow and SharedFlow are hot — they exist independently of collectors and share emissions.

Explanation

In an inline function with multiple lambda parameters, noinline marks specific lambdas that should be compiled as objects (not inlined), needed when storing the lambda.

Explanation

The Kotlin compiler emits intrinsic null-check bytecode (Intrinsics.checkNotNull) for non-null parameter receivers, plus @Nullable/@NonNull annotations for Java interop.

Explanation

(Int, String) -> Boolean is a function type taking Int and String and returning Boolean. The -> separates parameter types from the return type.

Explanation

KMP allows a commonMain source set to target Android (JVM), iOS (Kotlin/Native), Web (Kotlin/JS), and Desktop. Platform-specific implementations use expect/actual.

Explanation

expect class Platform() declares a type in commonMain. Each platform (androidMain, iosMain) provides actual class Platform() with its implementation.

Explanation

Cancellation is cooperative. Cancelling a Job propagates to all descendants. Suspending functions (like delay) check for cancellation and throw CancellationException when cancelled.

Explanation

synchronized blocks the thread while waiting for the lock. Mutex.withLock { } suspends the coroutine at lock acquisition, freeing the thread for other coroutines.

Explanation

tailrec fun factorial(n: Long, acc: Long = 1): Long is transformed by the compiler into a while loop, allowing deep recursion without stack overflow.

Explanation

The Kotlin compiler resolves expect/actual linkage at compile time. If a platform source set lacks an actual for an expected declaration, compilation fails.

Explanation

The Kotlin IR backend generates a common IR tree then uses backend-specific lowerings to produce JVM bytecode, JavaScript, or LLVM IR for Native targets.

Explanation

fun copy(from: Array<out T>, to: Array<in T>) — from is covariant (read-only), to is contravariant (write-only). This is use-site variance, complementing declaration-site variance.

Explanation

KSP (Kotlin Symbol Processing) is 2x faster than KAPT (Kotlin Annotation Processing) because it processes Kotlin's model directly, avoiding Java stub generation.

Explanation

context(Logger, Database) fun saveUser() can only be called where both Logger and Database are in scope, enabling type-safe dependency injection.

Explanation

Kotlin compiler plugins hook into compilation phases. kotlinx.serialization generates serializers. Compose rewrites @Composable functions. Arrow uses plugins for compile-time validation.

Explanation

Kotlin/Native uses LLVM for native compilation. Memory is managed with ARC (Automatic Reference Counting). Coroutines use a single-threaded model by default (strict immutability for sharing).

Explanation

Every suspend function receives an implicit Continuation parameter. When suspended, the current state is captured. When resumeWith is called, execution resumes from that state.