Android Development Kotlin Programming Syllabus

What is the difference between an abstract class and an interface in Kotlin?

An abstract class cannot be instantiated, can hold state, and may mix abstract and concrete members (abstract members are implicitly open). An interface cannot store state (no backing fields) but can have abstract members and default method implementations; a class can implement many interfaces but extend only one class.

List Kotlin's four visibility modifiers and their default.

public (default — visible everywhere), private (visible in the file or enclosing class), protected (visible in the class and subclasses; not for top-level), and internal (visible within the same module).

What does the internal visibility modifier mean in Kotlin?

internal makes a declaration visible everywhere within the same module (a set of files compiled together, e.g. a Gradle source set or IntelliJ module). It has no direct Java equivalent.

What is an extension function in Kotlin? Give an example.

An extension function adds a function to an existing type without modifying its source or inheriting from it. Example: fun String.lastChar(): Char = this[length - 1]. Inside, this is the receiver. Resolved statically at compile time.

Can an extension function override a member function with the same signature?

No. If a class already has a member function with the same name and signature, the member always takes precedence — extensions are dispatched statically by declared type and cannot override members.

What is a higher-order function in Kotlin?

A higher-order function is a function that takes another function as a parameter and/or returns a function. Example: fun calc(x: Int, op: (Int) -> Int): Int = op(x). Function types are written (params) -> ReturnType.

What is a lambda expression in Kotlin and how is it written?

A lambda is an anonymous function literal enclosed in braces: { x: Int -> x * 2 }. Parameters precede ->, and the last expression is the return value. A single parameter can be referenced implicitly as it.

What is the trailing lambda convention in Kotlin?

If the last parameter of a function is a lambda, it can be placed outside the parentheses: list.filter { it > 0 }. If the lambda is the only argument, the parentheses can be omitted entirely.

What is a coroutine in Kotlin?

A coroutine is a lightweight, suspendable computation for asynchronous, non-blocking programming. Many coroutines can run on few threads because suspension frees the thread rather than blocking it. Provided by the kotlinx.coroutines library.

What does the suspend keyword do in Kotlin?

suspend marks a function that can pause (suspend) execution without blocking the underlying thread and resume later. Suspend functions can only be called from another suspend function or a coroutine builder like launch or async.

Compare the launch and async coroutine builders.

launch starts a coroutine that does not return a result and returns a Job (fire-and-forget). async starts a coroutine that computes a value and returns a Deferred<T>, whose result is retrieved by calling await().

What is a CoroutineScope and why does structured concurrency matter?

A CoroutineScope defines the lifecycle and context in which coroutines run. Structured concurrency ties child coroutines to their scope, so cancelling or completing the scope cancels/awaits all children, preventing leaks. Examples: viewModelScope, lifecycleScope.

What is a Dispatcher in Kotlin coroutines and name the main ones.

A CoroutineDispatcher determines which thread(s) a coroutine runs on. Dispatchers.Main (UI thread), Dispatchers.IO (blocking I/O like network/disk), Dispatchers.Default (CPU-intensive work), and Dispatchers.Unconfined.

What is the difference between a List and a MutableList in Kotlin collections?

List is a read-only interface (only accessors like get, size); it cannot be modified through that reference. MutableList adds mutating operations (add, remove, set). listOf() creates a read-only list; mutableListOf() creates a mutable one.

Name Kotlin's three main collection types and their factory functions.

List (ordered, allows duplicates) via listOf/mutableListOf; Set (unordered, unique elements) via setOf/mutableSetOf; Map (key-value pairs) via mapOf/mutableMapOf. Each has read-only and mutable variants.

What do the map, filter, and reduce collection functions do?

map transforms each element and returns a new collection. filter keeps elements matching a predicate. reduce/fold accumulates elements into a single value (fold takes an initial value). All are higher-order functions that take lambdas.

What is the difference between a Sequence and a List for chained operations?

A List processes each operation eagerly, creating an intermediate collection at each step. A Sequence processes elements lazily, one element through the whole chain at a time, avoiding intermediates — more efficient for large data or long chains.

List Kotlin's five scope functions.

let, run, with, apply, and also. They execute a block of code in the context of an object, differing in how the object is referenced (this vs it) and what they return (the lambda result vs the object itself).

Compare apply and also scope functions.

Both return the context object itself (useful for chaining/configuration). apply references the object as this (implicit receiver, good for setting properties). also references it as it (good for side effects like logging or validation).

Compare let and run scope functions.

Both return the lambda result. let references the object as it and is common for null-checks (obj?.let { }) and scoping locals. run references the object as this and is handy for object configuration that computes a result.

How do you use string templates in Kotlin?

String templates embed expressions in a string with $. A simple variable: "Hello $name". An arbitrary expression uses braces: "Sum is ${a + b}". This avoids manual concatenation.

What is a raw (triple-quoted) string in Kotlin?

A raw string is delimited by triple quotes ("""...""") and contains no escaping — it preserves newlines and special characters literally. trimIndent() or trimMargin() is used to remove leading indentation.

Name three common Kotlin String functions for manipulation.

length (character count), substring(start, end), uppercase()/lowercase(), trim(), split(delimiter) (returns a List), replace(old, new), and contains/startsWith/endsWith. Strings are immutable, so these return new strings.

In Android, what does the 'Getting Started' step of enabling Kotlin involve for a new project?

In Android Studio, select Kotlin as the project language; the wizard applies the Kotlin Gradle plugin, adds the kotlin-stdlib dependency, and generates Activities in Kotlin. Existing Java projects can add Kotlin via 'Configure Kotlin in Project'.

What were Kotlin Android Extensions (kotlin-android-extensions) used for?

They provided synthetic view binding — importing kotlinx.android.synthetic.* let you access views directly by their XML id without findViewById. The plugin is now deprecated in favor of View Binding / Jetpack Compose.

Why were Kotlin synthetics (Kotlin Android Extensions) deprecated, and what replaced them?

Synthetics polluted the global namespace, exposed views from other layouts, and weren't null-safe or type-safe across modules. They were deprecated in 2020 and replaced by Jetpack View Binding (and Jetpack Compose).

In Android, how do coroutines help avoid blocking the main thread?

Long-running work (network, database) runs in a coroutine on a background dispatcher (Dispatchers.IO) using withContext, while UI updates happen on Dispatchers.Main. This keeps the UI responsive without callbacks, replacing AsyncTask.

What lifecycle-aware coroutine scopes does Android Jetpack provide?

viewModelScope (tied to a ViewModel, cancelled when it clears), lifecycleScope (tied to a Lifecycle owner like an Activity/Fragment), and repeatOnLifecycle for collecting flows only in a given state. They enforce structured concurrency and prevent leaks.

What frameworks are commonly used for unit testing Kotlin code?

JUnit (4 or 5) as the test runner with kotlin.test assertions, MockK for Kotlin-friendly mocking, and for coroutines kotlinx-coroutines-test (runTest, TestDispatcher). AssertJ or Truth are common assertion libraries.

How do you write and run a basic unit test in Kotlin with JUnit?

Annotate a function with @Test inside a test class and assert an expected outcome: @Test fun addsNumbers() { assertEquals(4, add(2, 2)) } Test files live in src/test/kotlin and are run via ./gradlew test.

How do you test suspend functions and coroutines in unit tests?

Use runTest from kotlinx-coroutines-test, which provides a controlled TestScope with virtual time so delays are skipped instantly: @Test fun example() = runTest { val result = fetchData() assertEquals(expected, result) }