Specifika Kotlinu v mobilním vývoji: co to je, jaké konstrukce a jak to funguje

Třídy (data class, sealed class, object, companion object)

Kotlin rozšiřuje koncepty tříd z Javy. data class, sealed class, object a companion object — konstrukce, které v Javě neexistují nebo jsou implementovány jinak.

data class vs sealed class

data class — třída automaticky generující equals(), hashCode(), toString(), copy() a componentN(). Ideální pro datové modely (DTO, Entity). Požadavky: alespoň jeden parametr v primárním konstruktoru, val/var, nemůže být open/sealed/inner. sealed class — třída s omezenou hierarchií podtříd. Všechny podtřídy jsou známy v době kompilace a deklarovány ve stejném souboru. Výraz when s sealed class nevyžaduje větev else. sealed interface (Kotlin 1.9+) — stejné jako sealed class, ale umožňuje vícenásobnou dědičnost. object — singleton, deklarovaný klíčovým slovem object (ne class). Thread-safe líná inicializace. companion object — statické členy třídy. Má jméno (výchozí Companion). Může implementovat rozhraní a mít extension functions.

data class — pro 90 % modelů. sealed class — pro UI State a Výsledek. object — pro singleton. IT Sectr doporučuje sealed class pro všechny stavy obrazovky (Loading, Success, Error).

Sealed class v praxi

Sealed class — mocný nástroj pro modelování stavů. Příklad: UiState<T> s podtřídami Loading, Success(data: T), Error(message: String). Výraz when zaručuje zpracování všech stavů. Sealed interface — pro události a akce, kde je potřeba vícenásobná implementace. Value class (Kotlin 1.5+) — obal pro jednu hodnotu bez režie. Používá se pro typově bezpečné identifikátory: @JvmInline value class UserId(val id: String).

Funkce (extension, inline, higher-order, scope functions)

Extension Function — přidání metody k existující třídě bez dědičnosti. fun String.isEmail(): Boolean. Extension Property — totéž pro vlastnosti (bez backing field). Inline Function — vložení těla funkce do místa volání — bez režie volání. Používá se pro higher-order funkce s lambdami. Higher-Order Function — funkce, která přijímá nebo vrací jinou funkci. Scope Functions — pět funkcí pro práci s kontextem objektu: let, run, with, apply, also.

Scope Functions

let — kontext it, vrací výsledek lambdy. Používá se pro null-safe volání (?.let {}). apply — kontext this, vrací kontext. Pro konfiguraci objektu. run — kontext this, vrací výsledek lambdy. Pro výpočty s kontextem. also — kontext it, vrací kontext. Pro vedlejší účinky (logování). with — není extension, kontext this, vrací výsledek lambdy. Pro skupinu operací na objektu. Lambda — anonymní funkce. Destructuring Declaration — rozbalení data class do proměnných: val (name, age) = person.

Inline + reified

Inline function s reified — jediný způsob, jak zachovat generický typ v JVM. Použití: typově bezpečné buildery (Gson.fromJson<T>()), kontrola typů (is T), získání třídy (T::class). Crossinline a Noinline — modifikátory pro parametry lambda v inline funkcích. crossinline — zakazuje non-local return, noinline — zakazuje inlining konkrétní lambdy. IT Sectr doporučuje inline + reified pouze při práci s typy; u běžných higher-order funkcí může inline zvýšit velikost bytekódu.

Korutiny (Coroutine Builder, Dispatchers, Scope)

Korutiny — lehká vlákna pro asynchronní programování. Neblokují vlákno — pozastavují se (suspend). suspend function — funkce, kterou lze pozastavit bez blokování vlákna. Lze volat pouze z korutiny nebo jiné suspend funkce.

CoroutineScope

CoroutineScope — rozsah pro korutiny. Obsahuje CoroutineContext (Job + Dispatcher). lifecycleScope — pro Activity/Fragment (Lifecycle-aware). viewModelScope — pro ViewModel (automatické zrušení při onCleared()). GlobalScope — globální rozsah (nepoužívat v produkci — úniky paměti). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (síť/disk), Dispatchers.Default (CPU-intenzivní), Dispatchers.Unconfined (nedoporučuje se). launch — spuštění korutiny: Job. async — spuštění s výsledkem: Deferred<T>. runBlocking — blokující most. withContext — změna Dispatcheru uvnitř suspend funkce.

// Příklad korutin: načítání dat ve ViewModel
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)
            }
        }
    }
}

// Paralelní požadavky s async
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 — standardní spuštění korutiny ve ViewModel. withContext(Dispatchers.IO) — přepnutí na IO vlákno pro síťový požadavek. Dispatchers určují, na kterém fondu vláken se korutina provádí. IT Sectr doporučuje viewModelScope pro ViewModel a lifecycleScope pro Activity/Fragment.

Pokročilé funkce (reified, destructuring, lateinit/lazy)

reified — modifikátor typu v inline funkcích. Umožňuje použít typ: T::class, is T, as T. Bez reified jsou generické typy v JVM vymazány (type erasure). inline fun + reified — mocná kombinace pro typově bezpečná API. Destructuring Declaration — val (x, y) = point. Funguje pro data class a typy s componentN(). typealias — alias typu: typealias Callback = (String) -> Unit. lateinit — odložená inicializace var (pro dependency injection). Není thread-safe. lazy — líná inicializace val (výchozí thread-safe). lazy(LazyThreadSafetyMode.NONE) — bez synchronizace. Extension function a Extension property — přidání funkcionality bez dědičnosti. Kotlin je jazyk, kde extension functions řeší 90 % pomocných úloh.

Delegované vlastnosti

Delegated Properties — delegování getter/setter na jiný objekt. Standardní delegáti: lazy, observable, vetoable, map. Vlastní delegát pomocí operátorů getValue/setValue. by — klíčové slovo delegování: val name by lazy { loadName() }. Delegované vlastnosti jsou základem pro ViewModel delegáty (by viewModels()). IT Sectr doporučuje lazy pro odloženou inicializaci a Delegates.observable pro sledování změn.

reified — pro typově bezpečná API. lazy — pro odložené načítání. delegated properties — pro opětovné použití logiky vlastností. IT Sectr doporučuje zvládnout všechny tyto funkce pro efektivní vývoj v Kotlinu.

Flow a StateFlow

Flow — studený asynchronní datový proud v Kotlinu. Vydává hodnoty na vyžádání kolektoru. StateFlow — horký Flow s jedinou aktuální hodnotou. Používá se ve ViewModel pro UI State. SharedFlow — horký Flow pro události (jednorázové události). flowOf, asFlow — vytvoření Flow z kolekcí. catch, retry, debounce — operátory. stateIn, shareIn — převod studeného Flow na horký. IT Sectr doporučuje StateFlow pro UI State a SharedFlow pro události (Snackbar, navigace).

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
    }
}

Serializace (kotlinx.serialization, Parcelize)

kotlinx.serialization — Kotlin knihovna pro JSON serializaci. @Serializable — anotace. @SerialName — vlastní název pole. Podporuje: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize pro Android Parcelable (bez ruční implementace). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, kompilačně bezpečný, bez reflexe. Moshi — anotace + codegen. IT Sectr doporučuje kotlinx.serialization pro nové projekty a Moshi pro stávající.

@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
)

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