Kotlin-specifikumok a mobilfejlesztésben: mi ez, milyen konstrukciók és hogyan működik

Osztályok (data class, sealed class, object, companion object)

A Kotlin kiterjeszti a Java osztályfogalmait. data class, sealed class, object és companion object — olyan konstrukciók, amelyek a Javában nem léteznek vagy másképp vannak implementálva.

data class vs sealed class

data class — egy osztály, amely automatikusan generálja az equals(), hashCode(), toString(), copy() és componentN() függvényeket. Ideális adatmodellekhez (DTO, Entity). Követelmények: legalább egy paraméter az elsődleges konstruktorban, val/var, nem lehet open/sealed/inner. sealed class — egy osztály korlátozott alosztály-hierarchiával. Minden alosztály fordítási időben ismert és ugyanabban a fájlban van deklarálva. A when kifejezés sealed class esetén nem igényel else ágat. sealed interface (Kotlin 1.9+) — ugyanaz, mint a sealed class, de többszörös öröklődést tesz lehetővé. object — singleton, az object kulcsszóval (nem class) deklarálva. Szálbiztos lusta inicializálás. companion object — egy osztály statikus tagjai. Neve van (alapértelmezett Companion). Implementálhat interfészeket és lehetnek extension functions.

data class — a modellek 90%-ához. sealed class — UI State és Eredmény esetén. object — singletonokhoz. Az IT Sectr a sealed class-t ajánlja minden képernyőállapothoz (Loading, Success, Error).

Sealed class a gyakorlatban

Sealed class — hatékony eszköz az állapotok modellezéséhez. Példa: UiState<T> a Loading, Success(data: T), Error(message: String) alosztályokkal. A when kifejezés garantálja az összes állapot kezelését. Sealed interface — eseményekhez és műveletekhez, ahol többszörös implementáció szükséges. Value class (Kotlin 1.5+) — egyetlen érték becsomagolása overhead nélkül. Típusbiztos azonosítókhoz használatos: @JvmInline value class UserId(val id: String).

Függvények (extension, inline, higher-order, scope functions)

Extension Function — metódus hozzáadása egy meglévő osztályhoz öröklődés nélkül. fun String.isEmail(): Boolean. Extension Property — ugyanez tulajdonságokhoz (backing field nélkül). Inline Function — a függvény törzsének beillesztése a hívás helyére — hívási overhead nélkül. Higher-order függvényekhez használatos lambda kifejezésekkel. Higher-Order Function — olyan függvény, amely másik függvényt fogad el vagy ad vissza. Scope Functions — öt függvény az objektum kontextusával való munkához: let, run, with, apply, also.

Scope Functions

let — kontextus it, visszaadja a lambda eredményét. Null-safe hívásokhoz használatos (?.let {}). apply — kontextus this, visszaadja a kontextust. Objektum konfigurálásához. run — kontextus this, visszaadja a lambda eredményét. Számításokhoz kontextussal. also — kontextus it, visszaadja a kontextust. Mellékhatásokhoz (naplózás). with — nem extension, kontextus this, visszaadja a lambda eredményét. Műveletcsoportokhoz egy objektumon. Lambda — névtelen függvény. Destructuring Declaration — data class kibontása változókra: val (name, age) = person.

Inline + reified

Inline function reified paraméterrel — az egyetlen mód a generikus típus megőrzésére a JVM-ben. Használata: típusbiztos builderek (Gson.fromJson<T>()), típusellenőrzés (is T), osztály lekérése (T::class). Crossinline és Noinline — módosítók lambda paraméterekhez inline függvényekben. crossinline — tiltja a non-local return-t, noinline — tiltja egy adott lambda inline-ját. Az IT Sectr csak típusokkal való munka esetén ajánlja az inline + reified használatát; hétköznapi higher-order függvényeknél az inline növelheti a bájtkód méretét.

Korutinok (Coroutine Builder, Dispatchers, Scope)

Korutinok — könnyű szálak aszinkron programozáshoz. Nem blokkolják a szálat — felfüggesztik (suspend). suspend function — olyan függvény, amely felfüggeszthető a szál blokkolása nélkül. Csak korutinból vagy másik suspend function-ból hívható.

CoroutineScope

CoroutineScope — korutinok hatóköre. CoroutineContext-et (Job + Dispatcher) tartalmaz. lifecycleScope — Activity/Fragment számára (Lifecycle-aware). viewModelScope — ViewModel számára (automatikus megszakítás onCleared() esetén). GlobalScope — globális hatókör (éles környezetben ne használja — memóriaszivárgás). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (hálózat/lemez), Dispatchers.Default (CPU-intenzív), Dispatchers.Unconfined (nem ajánlott). launch — korutin indítása: Job. async — indítás eredménnyel: Deferred<T>. runBlocking — blokkoló híd. withContext — Dispatcher váltása suspend függvényen belül.

// Példa korutinok: adatok betöltése ViewModel-ben
class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val data = withContext(Dispatchers.IO) {
                    repository.fetchData()
                }
                _state.value = UiState.Success(data)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message)
            }
        }
    }
}

// Párhuzamos kérések async segítségével
suspend fun loadCombinedData(): CombinedData = coroutineScope {
    val users = async(Dispatchers.IO) { api.getUsers() }
    val posts = async(Dispatchers.IO) { api.getPosts() }
    CombinedData(users.await(), posts.await())
}

viewModelScope.launch — szabványos korutin indítás ViewModel-ben. withContext(Dispatchers.IO) — átváltás IO szálra hálózati kéréshez. A Dispatchers határozza meg, hogy a korutin melyik szálkészleten fut. Az IT Sectr a viewModelScope-t ajánlja ViewModel-hez és a lifecycleScope-t Activity/Fragment-hez.

Speciális funkciók (reified, destructuring, lateinit/lazy)

reified — típusmódosító inline függvényekben. Lehetővé teszi a típus használatát: T::class, is T, as T. reified nélkül a generikusok a JVM-ben törlődnek (type erasure). inline fun + reified — erőteljes kombináció típusbiztos API-khoz. Destructuring Declaration — val (x, y) = point. Data class és componentN()-nel rendelkező típusok esetén működik. typealias — típus alias: typealias Callback = (String) -> Unit. lateinit — var késleltetett inicializálása (dependency injection-hez). Nem szálbiztos. lazy — val lusta inicializálása (alapértelmezetten szálbiztos). lazy(LazyThreadSafetyMode.NONE) — szinkronizáció nélkül. Extension function és Extension property — funkcionalitás hozzáadása öröklődés nélkül. A Kotlin olyan nyelv, ahol az extension functions a segédfeladatok 90%-át megoldja.

Delegált tulajdonságok

Delegated Properties — getter/setter delegálása másik objektumra. Szabványos delegátok: lazy, observable, vetoable, map. Egyéni delegát a getValue/setValue operátorokkal. by — delegációs kulcsszó: val name by lazy { loadName() }. A delegált tulajdonságok a ViewModel delegátok (by viewModels()) alapját képezik. Az IT Sectr a lazy-t ajánlja késleltetett inicializáláshoz és a Delegates.observable-t változások megfigyeléséhez.

reified — típusbiztos API-khoz. lazy — késleltetett betöltéshez. delegated properties — tulajdonságlogika újrafelhasználásához. Az IT Sectr javasolja mindezen funkciók elsajátítását a hatékony Kotlin-fejlesztéshez.

Flow és StateFlow

Flow — hideg aszinkron adatfolyam Kotlinban. Értékeket bocsát ki a gyűjtő kérésére. StateFlow — forró Flow egyetlen aktuális értékkel. ViewModel-ben használatos UI State-hez. SharedFlow — forró Flow eseményekhez (egyszeri események). flowOf, asFlow — Flow létrehozása gyűjteményekből. catch, retry, debounce — operátorok. stateIn, shareIn — hideg Flow átalakítása forróvá. Az IT Sectr a StateFlow-t ajánlja UI State-hez és a SharedFlow-t eseményekhez (Snackbar, navigáció).

class SearchViewModel : ViewModel() {
    private val _query = MutableStateFlow("")
    val suggestions: StateFlow<List<String>> = _query
        .debounce(300)
        .filter { it.length >= 2 }
        .flatMapLatest { repository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

Szerializáció (kotlinx.serialization, Parcelize)

kotlinx.serialization — Kotlin könyvtár JSON szerializációhoz. @Serializable — annotáció. @SerialName — egyéni mezőnév. Támogatja: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize Android Parcelable-hez (kézi implementáció nélkül). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, fordításbiztos, reflection nélkül. Moshi — annotációk + codegen. Az IT Sectr a kotlinx.serialization-t ajánlja új projektekhez és a Moshi-t meglévőkhöz.

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    @SerialName("data") val data: T? = null,
    val error: String? = null
)

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Deszerializáció
val json = Json { ignoreUnknownKeys = true }
val response = json.decodeFromString<ApiResponse<List<User>>>(jsonString)
println("Users: ${response.data?.size ?: 0}")