Kotlin за Android: основи на синтаксиса и възможности

Какво е Kotlin?

Kotlin — статично типизиран език за програмиране, създаден от JetBrains (разработчик на IntelliJ IDEA) и пуснат през 2016 г. под лиценз Apache 2.0. Kotlin се компилира до байткод на JVM, JavaScript и нативен код (чрез Kotlin/Native). Основна област на приложение — Android разработка, сървърни приложения и крос-платформени проекти.

Google обяви Kotlin за официален език за Android разработка на Google I/O 2017. Според данни на Google (Android Developer Blog, 2026), над 85% от новите проекти в Google Play използват Kotlin. Езикът се използва активно и в сървърната разработка (Spring Boot, Ktor) и в мултиплатформени проекти (Kotlin Multiplatform Mobile).

Kotlin е напълно съвместим с Java — можете да извиквате Java код от Kotlin и обратно в рамките на един проект. Инструментите за изграждане (Gradle, Maven) поддържат и двата езика, което позволява постепенна миграция от Java към Kotlin без престой в разработката.

Защо Kotlin е по-популярен от Java за Android

Основни причини: лаконичност — Kotlin изисква средно с 40% по-малко редове код от Java за една и съща задача. Null-безопасност — компилаторът забранява използването на nullable типове без проверка. Функционални възможности — функции от по-висок ред, ламбди, extension functions и корутини правят кода по-изразителен и безопасен.

Основи на синтаксиса

Основният синтаксис на Kotlin съчетава лаконичност с яснота. Променливите се декларират чрез val (immutable) и var (mutable). Компилаторът използва type inference, но изричното посочване на тип се поддържа. Функциите се декларират с ключовата дума fun.

package com.example.intro

// Константи и променливи
val appName: String = "KotlinApp"  // неизменяема
var version = 1.0  // променяема, типът е изведен

// Функция с expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "Здравей, $name! Версия ${appName}_$version"

// Default and named arguments
fun createUser(
    name: String,
    age: Int = 18,
    email: String? = null
)

When-изразът замества switch в Java и е по-гъвкав: поддържа проверка на типове, диапазони, условия и клонове без break. Компилаторът проверява изчерпателно покритие за enum и sealed-класове. Smart casts автоматично преобразуват типове след проверка is, елиминирайки изрични преобразувания.

fun analyzeValue(value: Any) = when (value) {
    is String -> "Низ с дължина ${value.length}"  // smart cast
    is Int -> "Цяло число: $value"
    in 1..10 -> "Число в диапазон 1-10"
    else -> "Неизвестен тип"
}

Null-безопасност и еливис-оператори

Null-безопасност — ключова функция на Kotlin, елиминираща NullPointerException на ниво компилация. В Kotlin типовете по подразбиране не могат да бъдат null. За да разрешите null, добавете ? към типа: String?. Компилаторът изисква изрична проверка на всяка nullable стойност.

// Nullable и non-null типове
val nonNull: String = "Винаги non-null"
val nullable: String? = null  // разрешено

// Safe call — изпълнява се само ако не е null
val length: Int? = nullable?.length

// Elvis operator — стойност по подразбиране
val text: String = nullable ?: "Default text"

// Let — изпълнение на блок с non-null стойност
nullable?.let { value ->
    println("Стойност: $value")
}

Safe call оператор (?.) връща null, ако обектът преди оператора е null, и извиква метода/свойството в противен случай. Elvis оператор (?:) предоставя стойност по подразбиране, ако лявата страна е null. Not-null assertion (!!) хвърля NullPointerException, ако стойността е null — използвайте само когато сте 100% сигурни в наличието на стойност.

Платформени типове (platform types) — Java типове от извикван Java код, които Kotlin не може да маркира като nullable или non-null. Типът се показва като String! (с удивителна). Разработчикът сам отговаря за null-безопасността при работа с Java код.

Data-класове и деструктуризация

Data-класовете в Kotlin автоматично генерират equals(), hashCode(), toString(), copy() и componentN(). Това елиминира шаблонния код на Java моделите (POJO) и прави кода по-чист. Декларацията на data class заема един ред вместо 20-30 в Java.

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int? = null
)

// Използване
val user = User(1, "Анна", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Деструктуризация
val (id, name) = user
println("Потребител #$id: $name")

Деструктуризацията позволява разлагане на data class на променливи в един ред. Това е удобно при работа с двойки, тройки и други композитни стойности. Деструктуризацията се поддържа за data-класове, стандартни колекции (List, Map) и всякакви класове с operator fun componentN().

Функции за разширение

Extension functions — механизъм на Kotlin за добавяне на нови методи към съществуващи класове без наследяване. Разширенията се компилират до статични методи с receiver параметър, така че наследяването не е необходимо и виртуалността не се поддържа.

// Extension function за String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Extension property
val String.isPhoneNumber: Boolean
    get() = this.matches(Regex("^\\+?[\\d-]{10,15}$"))

// Generic extension за колекции
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Използване
println("test@mail.com".isEmail())  // true

Разширенията се използват широко в Android SDK и библиотеки. Например Activity extensions в Android KTX са extension functions за Activity, Fragment, View и други класове. Разширенията могат да бъдат декларирани като top-level функции във файл или като членове на клас (member extensions).

Корутини за асинхронно програмиране

Coroutines — механизъм за асинхронно програмиране в Kotlin, позволяващ писане на неблокиращ код в последователен стил. Корутината спира изпълнението на suspend-функция без блокиране на нишката и възобновява работата след завършване на операцията. Това е алтернатива на callback веригите на RxJava и AsyncTask.

import kotlinx.coroutines.*

// Suspend-функция — може да се спира
suspend fun fetchUserData(userId: Int): User {
    // delay — suspend-функция, не блокира нишка
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Стартиране в корутина
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // спиране тук
        updateUI(user)  // продължение на основната нишка
    }
}

Dispatchers определят пула от нишки за корутината: Dispatchers.Main (UI нишка), Dispatchers.IO (мрежови/дискови операции), Dispatchers.Default (CPU-интензивни задачи). Structured concurrency гарантира, че корутината няма да остане активна след края на scope — това предотвратява изтичане на памет.

// Паралелно стартиране чрез async/await
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val user = async { fetchUserData(1) }
    val orders = async { fetchOrders(1) }
    val stats = async { fetchStats() }
    
    Dashboard(user.await(), orders.await(), stats.await())
}

Kotlin срещу Java: сравнение

Изборът между Kotlin и Java за нов Android проект — фундаментално архитектурно решение. Kotlin предлага по-модерен синтаксис и вградени механизми за сигурност, Java — по-широк набор от разработчици и зрели библиотеки.

Производителност на Kotlin и Java е сравнима — и двата се компилират до байткод на JVM. Kotlin понякога добавя микро-натоварване на корутини и inlining, но това е незначително за мобилни приложения. Google и JetBrains инвестират активно в Kotlin: Kotlin Multiplatform, Kotlin/Wasm и подобряване на производителността на компилатора K2.