Kotlin specifičnosti u mobilnom razvoju: šta je to, koje konstrukcije i kako radi

Klase (data class, sealed class, object, companion object)

Kotlin proširuje koncepte klasa iz Java. data class, sealed class, object i companion object — konstrukcije koje ne postoje u Java ili su drugačije implementirane.

data class vs sealed class

data class — klasa koja automatski generiše equals(), hashCode(), toString(), copy() i componentN(). Idealno za modele podataka (DTO, Entity). Zahtevi: najmanje jedan parametar u primarnom konstruktoru, val/var, ne može biti open/sealed/inner. sealed class — klasa sa ograničenom hijerarhijom podklasa. Sve podklase su poznate u vreme kompilacije i deklarisane u istoj datoteci. When izraz sa sealed class ne zahteva else granu. sealed interface (Kotlin 1.9+) — isto što i sealed class, ali dozvoljava višestruko nasleđivanje. object — singleton, deklariše se ključnom rečju object (ne class). Thread-safe lenja inicijalizacija. companion object — statički članovi klase. Ima ime (podrazumevano Companion). Može implementirati interfejse i imati extension functions.

data class — za 90% modela. sealed class — za UI State i Rezultat. object — za singleton-e. IT Sectr preporučuje sealed class za sva stanja ekrana (Loading, Success, Error).

Sealed class u praksi

Sealed class — moćan alat za modelovanje stanja. Primer: UiState<T> sa podklasama Loading, Success(data: T), Error(message: String). When izraz garantuje obradu svih stanja. Sealed interface — za događaje i akcije gde je potrebna višestruka implementacija. Value class (Kotlin 1.5+) — omotač za jednu vrednost bez overhead-a. Koristi se za tip-bezbedne identifikatore: @JvmInline value class UserId(val id: String).

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

Extension Function — dodavanje metode postojećoj klasi bez nasleđivanja. fun String.isEmail(): Boolean. Extension Property — isto za svojstva (bez backing field). Inline Function — umetanje tela funkcije na mesto poziva — bez overhead-a poziva. Koristi se za higher-order funkcije sa lambdama. Higher-Order Function — funkcija koja prihvata ili vraća drugu funkciju. Scope Functions — pet funkcija za rad sa kontekstom objekta: let, run, with, apply, also.

Scope Functions

let — kontekst it, vraća lambda rezultat. Koristi se za null-safe pozive (?.let {}). apply — kontekst this, vraća kontekst. Za konfiguraciju objekta. run — kontekst this, vraća lambda rezultat. Za izračunavanja sa kontekstom. also — kontekst it, vraća kontekst. Za sporedne efekte (logovanje). with — nije extension, kontekst this, vraća lambda rezultat. Za grupu operacija nad objektom. Lambda — anonimna funkcija. Destructuring Declaration — raspakivanje data class u promenljive: val (name, age) = person.

Inline + reified

Inline function sa reified — jedini način da se sačuva generički tip u JVM. Koristi se za: tip-bezbedne bildere (Gson.fromJson<T>()), proveru tipova (is T), dobijanje klase (T::class). Crossinline i Noinline — modifikatori za lambda parametre u inline funkcijama. crossinline — zabranjuje non-local return, noinline — zabranjuje inlining određene lambde. IT Sectr preporučuje inline + reified samo pri radu sa tipovima; za obične higher-order funkcije, inline može povećati veličinu bajtkoda.

Korutine (Coroutine Builder, Dispatchers, Scope)

Korutine — lake niti za asinhrono programiranje. Ne blokiraju nit — suspenduju se. suspend function — funkcija koja može biti suspendovana bez blokiranja niti. Može se pozvati samo iz korutine ili druge suspend funkcije.

CoroutineScope

CoroutineScope — opseg za korutine. Sadrži CoroutineContext (Job + Dispatcher). lifecycleScope — za Activity/Fragment (Lifecycle-aware). viewModelScope — za ViewModel (automatsko otkazivanje pri onCleared()). GlobalScope — globalni opseg (ne koristiti u produkciji — curenje memorije). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (mreža/disk), Dispatchers.Default (CPU-intensive), Dispatchers.Unconfined (ne preporučuje se). launch — pokreće korutinu: Job. async — pokreće sa rezultatom: Deferred<T>. runBlocking — blokirajući most. withContext — menja Dispatcher unutar suspend funkcije.

// Primer korutina: učitavanje podataka u 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)
            }
        }
    }
}

// Paralelni zahtevi sa 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 — standardno pokretanje korutine u ViewModel. withContext(Dispatchers.IO) — prebacivanje na IO nit za mrežni zahtev. Dispatchers određuju na kom se bazenu niti izvršava korutina. IT Sectr preporučuje viewModelScope za ViewModel i lifecycleScope za Activity/Fragment.

Napredne mogućnosti (reified, destructuring, lateinit/lazy)

reified — modifikator tipa u inline funkcijama. Dozvoljava korišćenje tipa: T::class, is T, as T. Bez reified, generici u JVM se brišu (type erasure). inline fun + reified — moćna kombinacija za tip-bezbedne API. Destructuring Declaration — val (x, y) = point. Radi za data class i tipove sa componentN(). typealias — alias tipa: typealias Callback = (String) -> Unit. lateinit — odložena inicijalizacija var (za dependency injection). Nije thread-safe. lazy — lenja inicijalizacija val (podrazumevano thread-safe). lazy(LazyThreadSafetyMode.NONE) — bez sinhronizacije. Extension function i Extension property — dodavanje funkcionalnosti bez nasleđivanja. Kotlin je jezik gde extension functions rešavaju 90% pomoćnih zadataka.

Delegirana svojstva

Delegated Properties — delegiranje getter/setter drugom objektu. Standardni delegati: lazy, observable, vetoable, map. Prilagođeni delegat preko getValue/setValue operatora. by — ključna reč delegiranja: val name by lazy { loadName() }. Delegirana svojstva su osnova za ViewModel delegate (by viewModels()). IT Sectr preporučuje lazy za odloženu inicijalizaciju i Delegates.observable za praćenje promena.

reified — za tip-bezbedne API. lazy — za odloženo učitavanje. delegated properties — za ponovno korišćenje logike svojstava. IT Sectr preporučuje savladavanje svih ovih mogućnosti za efikasan Kotlin razvoj.

Flow i StateFlow

Flow — hladan asinhroni tok podataka u Kotlin. Emituje vrednosti na zahtev kolektora. StateFlow — vruć Flow sa jednom trenutnom vrednošću. Koristi se u ViewModel za UI State. SharedFlow — vruć Flow za događaje (jednokratni događaji). flowOf, asFlow — kreiranje Flow iz kolekcija. catch, retry, debounce — operatori. stateIn, shareIn — konverzija hladnog Flow u vrući. IT Sectr preporučuje StateFlow za UI State i SharedFlow za događaje (Snackbar, navigacija).

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

Serijalizacija (kotlinx.serialization, Parcelize)

kotlinx.serialization — Kotlin biblioteka za JSON serijalizaciju. @Serializable — anotacija. @SerialName — prilagođeno ime polja. Podržava: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize za Android Parcelable (bez ručne implementacije). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, kompilaciono bezbedan, bez refleksije. Moshi — anotacije + codegen. IT Sectr preporučuje kotlinx.serialization za nove projekte i Moshi za postojeće.

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

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