Kotlin pentru Android: bazele sintaxei și capacitățile

Ce este Kotlin?

Kotlin — un limbaj de programare static tipizat creat de compania JetBrains (dezvoltatorul IntelliJ IDEA) și lansat în 2016 sub licența Apache 2.0. Kotlin se compilează în bytecode JVM, JavaScript și cod nativ (prin Kotlin/Native). Domeniul principal de aplicare — dezvoltarea Android, aplicații server și proiecte cross-platform.

Google a declarat Kotlin limbaj oficial de dezvoltare Android la Google I/O 2017. Conform datelor Google (Android Developer Blog, 2026), peste 85% din proiectele noi din Google Play folosesc Kotlin. Limbajul este de asemenea utilizat activ în dezvoltarea server (Spring Boot, Ktor) și în proiecte multiplatformă (Kotlin Multiplatform Mobile).

Kotlin este complet compatibil cu Java — se poate apela cod Java din Kotlin și invers în cadrul aceluiași proiect. Instrumentele de build (Gradle, Maven) suportă ambele limbaje, permițând migrarea treptată de la Java la Kotlin fără întreruperi în dezvoltare.

De ce Kotlin este mai popular decât Java pentru Android

Principalele motive: concizie — Kotlin necesită în medie cu 40% mai puține linii de cod decât Java pentru aceeași sarcină. Null-siguranță — compilatorul interzice utilizarea tipurilor nullable fără verificare. Capabilități funcționale — funcții de ordin superior, lambda, extension functions și corutine fac codul mai expresiv și mai sigur.

Bazele sintaxei

Sintaxa de bază Kotlin combină concizia cu claritatea. Variabilele se declară prin val (imutabil) și var (mutabil). Compilatorul folosește type inference, dar specificarea explicită a tipului este suportată. Funcțiile se declară cu cuvântul cheie fun.

package com.example.intro

// Constante și variabile
val appName: String = "KotlinApp"  // imutabilă
var version = 1.0  // mutabilă, tip dedus

// Funcție cu expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "Salut, $name! Versiunea ${appName}_$version"

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

When-expresia înlocuiește switch din Java și este mai flexibilă: suportă verificarea tipurilor, intervaluri, condiții și ramuri fără break. Compilatorul verifică acoperirea exhaustivă pentru enum și clase sealed. Smart casts convertesc automat tipurile după verificarea is, eliminând conversiile explicite.

fun analyzeValue(value: Any) = when (value) {
    is String -> "Șir de lungime ${value.length}"  // smart cast
    is Int -> "Număr întreg: $value"
    in 1..10 -> "Număr în intervalul 1-10"
    else -> "Tip necunoscut"
}

Null-siguranță și operatorii elvis

Null-siguranța — caracteristica cheie a Kotlin care elimină NullPointerException la nivel de compilare. În Kotlin, tipurile implicit nu pot fi null. Pentru a permite null, adăugați ? la tip: String?. Compilatorul necesită verificarea explicită a fiecărei valori nullable.

// Tipuri nullable și non-null
val nonNull: String = "Întotdeauna non-null"
val nullable: String? = null  // permis

// Safe call — se execută doar dacă nu este null
val length: Int? = nullable?.length

// Elvis operator — valoare implicită
val text: String = nullable ?: "Default text"

// Let — executare bloc cu valoare non-null
nullable?.let { value ->
    println("Valoare: $value")
}

Operatorul Safe call (?.) returnează null dacă obiectul dinaintea operatorului este null și apelează metoda/proprietatea în caz contrar. Operatorul Elvis (?:) oferă o valoare implicită dacă partea stângă este null. Aserțiunea Not-null (!!) aruncă NullPointerException dacă valoarea este null — utilizați doar când sunteți 100% sigur de existența valorii.

Tipuri platformă (platform types) — tipuri Java din codul Java apelat pe care Kotlin nu le poate marca ca nullable sau non-null. Tipul se afișează ca String! (cu semnul exclamării). Dezvoltatorul este responsabil pentru null-siguranță la lucrul cu cod Java.

Clase de date și destructurare

Clasele de date în Kotlin generează automat equals(), hashCode(), toString(), copy() și componentN(). Acest lucru elimină boilerplate-ul modelelor Java (POJO) și face codul mai curat. Declarația unui data class ocupă o singură linie în loc de 20-30 în Java.

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

// Utilizare
val user = User(1, "Ana", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Destructurare
val (id, name) = user
println("Utilizator #$id: $name")

Destructurarea permite descompunerea unui data class în variabile într-o singură linie. Este convenabil la lucrul cu perechi, triplete și alte valori compozite. Destructurarea este suportată pentru clasele de date, colecțiile standard (List, Map) și orice clase cu operator fun componentN().

Funcții de extensie

Extension functions — mecanismul Kotlin pentru adăugarea de noi metode la clasele existente fără moștenire. Extensiile se compilează în metode statice cu parametru receiver, deci moștenirea nu este necesară și virtualitatea nu este suportată.

// Extension function pentru 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 pentru colecții
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Utilizare
println("test@mail.com".isEmail())  // true

Extensiile sunt utilizate pe scară largă în Android SDK și biblioteci. De exemplu, Activity extensions în Android KTX sunt extension functions pentru Activity, Fragment, View și alte clase. Extensiile pot fi declarate ca funcții top-level într-un fișier sau ca membri ai clasei (member extensions).

Corutine pentru programare asincronă

Coroutines — este mecanismul de programare asincronă în Kotlin care permite scrierea codului neblocant în stil secvențial. O corutină suspendă execuția pe o funcție suspend fără a bloca firul de execuție și reia lucrul după finalizarea operației. Aceasta este o alternativă la lanțurile de callback RxJava și AsyncTask.

import kotlinx.coroutines.*

// Funcție Suspend — se poate întrerupe
suspend fun fetchUserData(userId: Int): User {
    // delay — funcție suspend, nu blochează firul
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Pornire în corutină
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // întrerupere aici
        updateUI(user)  // continuare pe firul principal
    }
}

Dispatchers determină pool-ul de fire pentru corutină: Dispatchers.Main (fir UI), Dispatchers.IO (operații rețea/discc), Dispatchers.Default (sarcini CPU-intensive). Structured concurrency garantează că corutina nu rămâne activă după finalizarea scope-ului — acest lucru previne scurgerile de memorie.

// Pornire paralelă prin 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 versus Java: comparație

Alegerea între Kotlin și Java pentru un nou proiect Android — o decizie arhitecturală fundamentală. Kotlin oferă o sintaxă mai modernă și mecanisme de securitate încorporate, Java — un pool mai larg de dezvoltatori și biblioteci mature.

Performanța Kotlin și Java este comparabilă — ambele se compilează în bytecode JVM. Kotlin adaugă uneori un micro-supliment pentru corutine și inlining, dar acest lucru este nesemnificativ pentru aplicațiile mobile. Google și JetBrains investesc activ în Kotlin: Kotlin Multiplatform, Kotlin/Wasm și îmbunătățirea performanței compilatorului K2.