Kotlin: вопросы для собеседования QA

Kotlin — современный язык от JetBrains, работающий на JVM (а также на Android, в браузере через Kotlin/JS, нативно через Kotlin/Native). Полностью совместим с Java.

Главные отличия: null-безопасность на уровне типов, data class, extension functions, корутины, лаконичный синтаксис, smart casts, scope-функции (let, run, also, apply, with), поддержка функционального стиля.

Из практики: на Android Kotlin стал основным языком, для бэкенда — частый выбор для новых сервисов. Совместимость с Java позволяет постепенно мигрировать или смешивать в одном проекте.

val — это неизменяемая ссылка (read-only), её нельзя переприсвоить после инициализации. var — изменяемая, можно переприсваивать.

Важно: val не делает объект иммутабельным, только ссылку. val list = mutableListOf(1, 2) — нельзя переприсвоить list, но можно list.add(3).

Из практики: по умолчанию всегда используйте val. Кода становится предсказуемее, проще читать и тестировать. var включают, только когда без него не обойтись.

Тип в Kotlin по умолчанию ненулевой: String — нельзя присвоить null. Для допустимого null используют тип с вопросом: String?. Компилятор требует обрабатывать null-случай.

Операторы: ?. (безопасный вызов, вернёт null если получатель null), ?: (Elvis — значение по умолчанию, если null), !! (утверждение «точно не null», бросит NPE если ошиблись).

Из практики: правильно расставленные ?, ?., ?: и отказ от !! почти полностью устраняют NullPointerException. Это одна из основных причин выбора Kotlin.

data class — это класс, у которого компилятор автоматически генерирует equals, hashCode, toString, copy и componentN для деструктуризации. Объявляется ключевым словом data перед class.

Подходит для классов-носителей данных: модели API, DTO, value-объекты. data class User(val name: String, val age: Int).

Из практики: copy позволяет создавать слегка изменённую копию, не мутируя оригинал: user.copy(age = 31). Это поддерживает иммутабельный стиль.

Расширяющая функция позволяет добавить к существующему типу новый метод без наследования и модификации исходного класса. fun String.lastChar(): Char = this[this.length - 1] — теперь любая String умеет lastChar().

Под капотом это обычная статическая функция, принимающая получатель первым аргументом. Поэтому диспатч статический, без виртуальности.

Из практики: extension functions помогают создавать читаемые DSL, расширять чужие классы (включая стандартную библиотеку) без обёрток и держать вспомогательную логику рядом с типом.

Это пять функций, которые принимают лямбду и работают со «своим» объектом. Различаются тем, что внутри (this или it) и что возвращают (получатель или результат лямбды).

let — it, возвращает результат лямбды (часто для null?.let). run — this, возвращает результат лямбды (для конфигурации с возвратом). also — it, возвращает получатель (для побочных эффектов). apply — this, возвращает получатель (для инициализации). with — не extension, this, возвращает результат лямбды.

Из практики: typical idioms — value?.let { ... } для безопасной работы с null, builder().apply { fieldA = 1 } для конструирования, save().also { log.info(it) } для логирования.

Корутина — это лёгкий поток исполнения, который может приостанавливаться (suspend) и возобновляться без блокировки треда. На одном тысячах корутин запросто работают на десятке OS-потоков.

Запускают через билдеры: launch (fire-and-forget), async (с результатом, возвращает Deferred), runBlocking (для тестов и точек входа). suspend-функции — это функции, которые умеют приостанавливаться.

Из практики: для асинхронной работы (сетевые запросы, БД, чтение файлов) корутины дают код, читающийся как синхронный, но без блокировки потоков. Решают те же задачи, что и потоки/RxJava, но проще.

suspend помечает функцию, которая может приостанавливаться. Её можно вызывать только из другой suspend-функции или внутри корутины (launch/async/runBlocking).

Компилятор превращает suspend-функцию в state machine, передавая Continuation. Снаружи это похоже на обычный вызов, но под капотом — машина состояний.

Из практики: suspend-функции — это асинхронный код, который читается как синхронный. Подходит для сетевых запросов, БД, файловых операций. Передавайте все асинхронные API через suspend, не маскируйте runBlocking.

launch запускает корутину и возвращает Job — управляющий объект без значения результата. Используется для побочных действий (логирование, отправка событий).

async запускает и возвращает Deferred<T> — это Job, у которой есть await(), возвращающий результат. Используется для параллельных вычислений с результатом.

Из практики: для двух параллельных запросов делают val a = async { fetchA() }; val b = async { fetchB() }; val res = a.await() + b.await().

sealed class — это класс с ограниченным набором наследников, объявленных в том же файле или модуле. Компилятор знает обо всех вариантах.

При использовании в when можно не писать else: компилятор проверит, что покрыты все ветки. Это даёт исчерпывающую обработку и помогает при добавлении нового варианта — компилятор укажет на все when, где его не обработали.

Из практики: классический инструмент для представления результатов с разными «формами» (Success, Error, Loading), команд, состояний. Лучше иерархии чем enum, потому что каждый вариант может нести свои данные.

when — это конструкция выбора по значению. В отличие от switch в Java, она может быть выражением (возвращать значение), не требует break, поддерживает любые типы и сложные условия в ветках.

Можно матчить интервалы (in 1..10), типы (is String), произвольные предикаты (when { x > 0 -> ... }) и проверять на сразу несколько значений через запятую.

Из практики: when заменяет if/else if/else цепочки и читается гораздо чище. Особенно силен с sealed классами — даёт исчерпывающую проверку.

В Kotlin нет ключевого слова static. Для «статичных» членов используют companion object — единственный объект, привязанный к классу. Доступ из кода: ClassName.member.

В отличие от static, companion object — настоящий объект, он может реализовывать интерфейсы, его можно передавать как значение. Для совместимости с Java добавляют аннотации @JvmStatic, @JvmField.

Из практики: companion object используют для фабрик, констант, фабричных методов. Если нужно вызывать из Java как обычный static — обязательно @JvmStatic.

object — это объявление одиночного объекта (singleton). object Repository { fun load() {...} } — один экземпляр, к которому обращаются по имени.

Также object используют для анонимных объектов (вместо anonymous inner class в Java): val listener = object : Listener { override fun onClick() {...} }.

Из практики: для классических синглтонов в Kotlin не нужны паттерны на double-checked locking — object безопасно создаётся лениво при первом обращении.

Smart cast — это автоматическое приведение типа после проверки. Если компилятор видит is String, дальше в ветке переменная уже имеет тип String без явного приведения.

Работает для локальных переменных, val-свойств без custom getter и параметров функций. Не работает для var-свойств открытого класса или mutable свойств из другого модуля, потому что между проверкой и использованием значение может измениться.

Из практики: упрощает работу с when (is ...) -> и null-проверками. Когда smart cast не срабатывает (например, для var), компилятор сам подскажет, что нужно сохранить в локальную val.

inline у функции говорит компилятору: подставлять её тело в место вызова, а не делать обычный вызов. Особенно полезно для функций с лямбдой-параметром — лямбда инлайнится тоже, и нет аллокации объекта-лямбды.

Это даёт нулевую накладную стоимость для функций типа let, run, forEach, и позволяет внутри inline-функции делать non-local return из вызывающего кода.

Из практики: писать свои inline-функции имеет смысл, когда они принимают лямбды и вызываются часто. Просто все подряд функции inline-ить вредно — раздувается код.

Обычно дженерики на JVM стираются — внутри функции нельзя узнать конкретный T. Но в inline-функции, если параметр пометить как reified, компилятор подставит тип на этапе компиляции, и его можно использовать как обычный класс.

Пример: inline fun <reified T> parse(json: String): T = mapper.readValue(json, T::class.java). Снаружи parse<User>(json) автоматически передаст класс User.

Из практики: убирает шаблонный код вида readValue(json, User::class.java). Особенно ценно в утилитах сериализации и DI.

Делегирование свойства — это механизм, передающий get/set другому объекту через ключевое слово by. val name: String by lazy { computeName() } — значение вычисляется при первом обращении.

Встроенные делегаты: lazy (ленивая инициализация), Delegates.observable (уведомлять на каждое изменение), Delegates.vetoable (разрешать/запрещать изменение), map (читать из Map).

Из практики: by lazy — типовое решение для тяжёлых вычислений и кешей. observable — для UI и реактивных моделей. Также можно писать свои делегаты, реализуя getValue/setValue.

enum — это набор фиксированных именованных значений. Каждое значение — один и тот же тип, и у всех значений одинаковый набор полей. Подходит для конечного набора констант (Color, Status).

sealed class — это набор ограниченных подтипов, у каждого может быть свой состав полей и поведение. Подходит, когда «варианты» разнообразны (Loading, Success(data), Error(message)).

Из практики: если каждый вариант — просто метка с одинаковой структурой, выбирайте enum; если варианты несут разные данные — sealed. Их можно сочетать: enum-класс может реализовывать sealed interface (но не наследовать sealed class — у enum уже есть неявный родитель Enum), а внутри sealed class можно объявить вложенный enum.

Деструктуризация позволяет распаковать объект в отдельные переменные: val (name, age) = user. Работает с data class (там componentN сгенерирован автоматически) и с любым типом, у которого есть operator fun componentN.

Удобно в циклах и при работе с парами/мапами: for ((key, value) in map) { ... }. Игнорировать поле можно через _: val (a, _, c) = triple.

Из практики: помогает делать код лаконичным при работе с DTO и tuple-подобными типами. Особенно при возврате нескольких значений из функции.

typealias задаёт синоним для существующего типа: typealias UserId = String или typealias Handler<T> = (T) -> Unit. Не создаёт новый тип — это именно псевдоним.

Полезен для семантической читаемости (UserId вместо String), для сокращения сложных дженериков, для упрощения функциональных сигнатур.

Из практики: typealias не заменяет value class и не даёт защиты типизации — UserId и любая String взаимозаменяемы. Для строгой типизации нужен value class (inline class).

Extension property — это свойство, добавленное к типу как расширение, по аналогии с extension function. val String.lastChar: Char get() = this[length - 1].

У него не может быть backing field — это всегда вычисляемое свойство, реализующееся через get (и set, если var).

Из практики: хороший способ добавить «инструкции для чтения» к типу — например, val List<T>.secondOrNull: T?. Просит ввести вспомогательную переменную, оставаясь компактным синтаксически.

CoroutineScope ограничивает время жизни корутин: при отмене scope отменяются и все его дочерние корутины. Это и есть структурный параллелизм — гарантия, что не остаётся «забытых» работ.

В Android есть готовые scope: viewModelScope, lifecycleScope. На бэкенде scope привязывают к запросу, юниту работы, тесту. Внутри функций используют coroutineScope { ... } для подзадач.

Из практики: благодаря structured concurrency сложно создать утечку — каждая корутина имеет родителя и заканчивается с ним. Это резко проще, чем ручное управление потоками.

Flow — это асинхронная последовательность значений, аналог Observable из RxJava, но интегрированный в корутины. Производитель эмитит через emit, потребитель собирает через collect.

Cold by default — Flow ничего не делает, пока его не collect. У него богатый набор операторов: map, filter, debounce, flatMapConcat, retry, take. Поддерживает backpressure естественным образом.

Из практики: Flow используют для потоков данных (события UI, push из бэкенда, БД-наблюдатели). StateFlow и SharedFlow — горячие версии для состояния и событий.

Kotlin компилируется в обычный JVM-байткод, поэтому Java-классы и Kotlin-классы могут вызывать друг друга. Большая часть API Kotlin доступна из Java напрямую.

Подводные камни: platform-типы (Java возвращает то, что может быть null, Kotlin видит это как T! и не проверяет), companion object из Java виден как ClassName.Companion (нужен @JvmStatic), extension function видна как статический метод утилитного класса, дефолтные значения параметров требуют @JvmOverloads.

Из практики: при работе с Java-API расставляйте @Nullable/@NotNull в Java или принимайте на стороне Kotlin String? для безопасности. Для библиотек, которые будут звать из Java, добавляйте @Jvm-аннотации.

data class — для носителей данных с автогенерируемыми equals/hashCode/toString/copy. Подходит для DTO и моделей.

value class (раньше inline class) — обёртка над одним полем без накладных расходов рантайма. Идеально для семантических обёрток (UserId, Email) с защитой типизации.

Обычный class — для всего остального: сервисы, сущности с identity, классы с поведением. Из практики: для сущностей с жизненным циклом избегайте data class — равенство по значению сбивает с толку. value class — мощное средство против case «передал email вместо username».

Unit — это аналог void в Java: функция ничего не возвращает (точнее, возвращает единственное значение Unit). По умолчанию подразумевается, если возвращаемый тип не указан.

Nothing — тип, означающий «функция не возвращается нормально» (бросает исключение или бесконечный цикл). Используется как маркер для компилятора.

Из практики: Nothing полезен в утилитах throw fail("msg"): val x: String = nullableValue ?: fail("..."). Компилятор знает, что после fail значение не вернётся.

По умолчанию классы и методы в Kotlin final — нельзя наследовать/переопределять. Чтобы разрешить — open перед объявлением.

Это противоположно Java, где по умолчанию всё «открыто». Идея — безопаснее по умолчанию: явно выбираем, что можно переопределить.

Из практики: для тестируемости (mock-фреймворки) иногда мешает — приходится либо open, либо использовать allopen-плагин Gradle.

public (по умолчанию — доступен везде), internal (внутри модуля), protected (в классе и наследниках, не для top-level), private (в классе или файле).

internal — особенный: ограничивает доступ модулем (gradle subproject). Удобно для библиотек: внутренняя API не видна снаружи.

Из практики: для библиотек минимальная по умолчанию public — это анти-паттерн. Лучше использовать internal/private для всего, кроме явного публичного API.

Функция, помеченная infix, вызывается без точки и скобок: a func b вместо a.func(b). Должна быть с одним параметром, методом класса или extension.

Используется для удобства DSL: 1 to "a" (создаёт Pair), shouldEqual, until.

Из практики: infix делает код выразительнее в определённых контекстах. Не злоупотребляйте — обычные методы читаются понятнее в большинстве случаев.

operator перед функцией позволяет переопределить операторы: plus → +, minus → -, get → [], invoke → (). Например, operator fun Point.plus(other: Point) даёт p1 + p2.

Имена операторов стандартизованы — каждый соответствует своей сигнатуре.

Из практики: незаменимо для математических классов, DSL, контейнеров. Без злоупотреблений — делает API натуральнее.

out T — ковариантный параметр (T только в позициях производства, нельзя в потреблении). in T — контравариантный (только в потреблении).

Пример: List<out T> — можно List<String> присвоить переменной типа List<Any>, потому что только читаем. MutableList<in T> — наоборот, можно писать.

Из практики: правило PECS — Producer Extends (out), Consumer Super (in). Понимание помогает писать гибкие API без warnings.

typealias задаёт синоним для существующего типа: typealias UserId = String, typealias Handler = (Event) -> Unit. Не создаёт новый тип — это псевдоним.

Полезен для документации (UserId говорит больше, чем String), для сокращения сложных функциональных сигнатур.

Из практики: typealias не даёт типобезопасности — UserId и любая String взаимозаменяемы. Для строгой типизации — value class.

with(obj) { ... } — не extension, возвращает результат лямбды, this — obj. apply { ... } — extension, возвращает сам объект, this — obj. also { ... } — extension, возвращает объект, it — объект. let { ... } — extension, возвращает результат, it — объект.

Выбор: для конфигурации с возвратом — apply. Для побочного действия — also. Для null-safe вызова — let. Для группировки операций — with.

Из практики: путаница между ними — обычное дело. Главное — последовательность внутри проекта.

CoroutineContext — это набор элементов корутины: Job, dispatcher, name. Dispatcher определяет, на каком потоке (или пуле) исполняется корутина: Default (CPU), IO (блокирующий IO), Main (UI), Unconfined.

withContext(Dispatchers.IO) переключает выполнение на IO-пул. После withContext возвращается на исходный.

Из практики: для сетевых запросов и БД — IO. Для CPU-bound — Default. UI-обновления — Main. Не использовать Main для тяжёлых операций.

В launch исключение пробрасывается родителю scope и (если не обработано) распространяется выше. В async исключение хранится в Deferred и выкидывается на await.

CoroutineExceptionHandler можно добавить в context, чтобы перехватить unhandled exception в launch. SupervisorJob изолирует братьев — упал один не отменит других.

Из практики: всегда явно обрабатывайте исключения в launch — иначе они уничтожают весь scope. В async помните про await.

sealed interface — то же, что sealed class, но интерфейс. Можно использовать для иерархий с множественным наследованием.

Идеален для алгебраических типов: sealed interface Result<T>; class Success<T>(val value: T): Result<T>; class Failure(val error: String): Result<Nothing>.

Из практики: для современного Kotlin sealed interface часто предпочтительнее sealed class, потому что можно комбинировать с другими интерфейсами.

Context receivers (экспериментально в Kotlin 1.6+) позволяют функции «требовать» наличия определённого контекста: context(Logger) fun process() { log(...) }.

Это шаг к более удобному DI и DSL — без явной передачи параметров.

Из практики: пока экспериментально, в production code лучше использовать осторожно. Может пригодиться в библиотеках с богатым DSL.

Channel — это асинхронная очередь между корутинами. Send и receive — suspend-функции. Поддерживает buffering, conflated (последнее значение), broadcast.

Похоже на Channel в Go. Используется для producer-consumer паттерна.

Из практики: для большинства сценариев достаточно Flow. Channel — когда нужна явная очередь между несколькими producer/consumer.

Kotlin DSL — domain-specific language внутри Kotlin. Строится через lambda with receiver, extension functions, operator functions, infix.

Примеры: Gradle Kotlin DSL, kotlinx.html, Anko, Ktor routes.

Из практики: для специфичных задач DSL даёт более выразительный код. Но требует осторожности — слишком сложный DSL непонятен новичкам.

KMP (Kotlin Multiplatform) — кодшеринг между Android, iOS, JVM, JS, Native. Общая бизнес-логика, специфичный UI для каждой платформы.

Compose Multiplatform — общий UI для Android, iOS, desktop, web (экспериментально).

Из практики: KMP — серьёзный кандидат для команд, разрабатывающих под несколько платформ. Зрелость растёт, продакшен-кейсы — Cash App, Philips Hue, Netflix.

value class (раньше inline class) — обёртка вокруг одного поля, не создающая объект в runtime для большинства случаев. Идеально для семантических обёрток: UserId над String, Email над String.

Даёт типобезопасность (нельзя перепутать UserId и Email) без overhead.

Из практики: для строгой типизации — отличный инструмент. В некоторых случаях (generics, nullable) всё-таки создаётся объект (boxing) — нужно понимать.