Kotlin-specifikationer inom mobil utveckling: vad det är, vilka konstruktioner och hur det fungerar

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

Kotlin utökar klasskoncepten från Java. data class, sealed class, object och companion object — konstruktioner som inte finns i Java eller är implementerade annorlunda.

data class vs sealed class

data class — en klass som automatiskt genererar equals(), hashCode(), toString(), copy() och componentN(). Idealisk för datamodeller (DTO, Entity). Krav: minst en parameter i primärkonstruktorn, val/var, kan inte vara open/sealed/inner. sealed class — en klass med en begränsad underklasshierarki. Alla underklasser är kända vid kompilering och deklarerade i samma fil. När-uttryck med sealed class kräver ingen else-gren. sealed interface (Kotlin 1.9+) — samma som sealed class men tillåter multipelt arv. object — en singleton, deklarerad med nyckelordet object (inte class). Trådsäker lat initiering. companion object — statiska medlemmar i en klass. Har ett namn (standard Companion). Kan implementera gränssnitt och ha extension functions.

data class — för 90% av modellerna. sealed class — för UI State och Resultat. object — för singleton. IT Sectr rekommenderar sealed class för alla skärmtillstånd (Loading, Success, Error).

Sealed class i praktiken

Sealed class — ett kraftfullt verktyg för att modellera tillstånd. Exempel: UiState<T> med underklasser Loading, Success(data: T), Error(message: String). När-uttrycket garanterar hantering av alla tillstånd. Sealed interface — för händelser och åtgärder där multipel implementering behövs. Value class (Kotlin 1.5+) — ett omslag för ett enskilt värde utan överhead. Används för typsäkra identifierare: @JvmInline value class UserId(val id: String).

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

Extension Function — lägga till en metod till en befintlig klass utan arv. fun String.isEmail(): Boolean. Extension Property — samma för egenskaper (utan backing field). Inline Function — infoga funktionskroppen vid anropsplatsen — utan anropsöverhead. Används för higher-order-funktioner med lambdas. Higher-Order Function — en funktion som tar emot eller returnerar en annan funktion. Scope Functions — fem funktioner för att arbeta med objektkontext: let, run, with, apply, also.

Scope Functions

let — kontext it, returnerar lambda-resultat. Används för null-säkra anrop (?.let {}). apply — kontext this, returnerar kontext. För objektkonfiguration. run — kontext this, returnerar lambda-resultat. För beräkningar med kontext. also — kontext it, returnerar kontext. För sidoeffekter (loggning). with — är inte extension, kontext this, returnerar lambda-resultat. För en grupp operationer på ett objekt. Lambda — anonym funktion. Destructuring Declaration — uppackning av data class till variabler: val (name, age) = person.

Inline + reified

Inline function med reified — det enda sättet att bevara en generisk typ i JVM. Används för: typsäkra byggare (Gson.fromJson<T>()), typkontroll (is T), hämta klass (T::class). Crossinline och Noinline — modifierare för lambda-parametrar i inline-funktioner. crossinline — förbjuder non-local return, noinline — förbjuder inlining av en specifik lambda. IT Sectr rekommenderar inline + reified endast vid arbete med typer; för vanliga higher-order-funktioner kan inline öka bytekodens storlek.

Korutiner (Coroutine Builder, Dispatchers, Scope)

Korutiner — lätta trådar för asynkron programmering. De blockerar inte tråden — de pausar (suspend). suspend function — en funktion som kan pausas utan att blockera tråden. Kan endast anropas från en korutin eller en annan suspend-funktion.

CoroutineScope

CoroutineScope — ett omfång för korutiner. Innehåller CoroutineContext (Job + Dispatcher). lifecycleScope — för Activity/Fragment (livscykelmedveten). viewModelScope — för ViewModel (automatisk avbokning vid onCleared()). GlobalScope — globalt omfång (använd inte i produktion — minnesläckor). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (nätverk/disk), Dispatchers.Default (CPU-intensiv), Dispatchers.Unconfined (rekommenderas inte). launch — startar en korutin: Job. async — startar med resultat: Deferred<T>. runBlocking — blockerande brygga. withContext — byter Dispatcher inuti en suspend-funktion.

// Exempel korutiner: ladda data i 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)
            }
        }
    }
}

// Parallella förfrågningar med 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 — standardstart av korutin i ViewModel. withContext(Dispatchers.IO) — växla till IO-tråd för nätverksbegäran. Dispatchers avgör på vilken trådpool korutinen körs. IT Sectr rekommenderar viewModelScope för ViewModel och lifecycleScope för Activity/Fragment.

Avancerade funktioner (reified, destructuring, lateinit/lazy)

reified — en typmodifierare i inline-funktioner. Tillåter användning av typen: T::class, is T, as T. Utan reified raderas generics i JVM (type erasure). inline fun + reified — en kraftfull kombination för typsäkra API:er. Destructuring Declaration — val (x, y) = point. Fungerar för data class och typer med componentN(). typealias — typalias: typealias Callback = (String) -> Unit. lateinit — fördröjd initiering av var (för dependency injection). Inte trådsäker. lazy — lat initiering av val (normalt trådsäker). lazy(LazyThreadSafetyMode.NONE) — utan synkronisering. Extension function och Extension property — lägg till funktionalitet utan arv. Kotlin är ett språk där extension functions löser 90% av hjälpuppgifterna.

Delegerade egenskaper

Delegated Properties — delegera getter/setter till ett annat objekt. Standarddelegater: lazy, observable, vetoable, map. Anpassad delegat via getValue/setValue-operatorer. by — delegeringsnyckelord: val name by lazy { loadName() }. Delegerade egenskaper är grunden för ViewModel-delegater (by viewModels()). IT Sectr rekommenderar lazy för fördröjd initiering och Delegates.observable för att observera ändringar.

reified — för typsäkra API:er. lazy — för fördröjd laddning. delegated properties — för återanvändning av egenskapslogik. IT Sectr rekommenderar att bemästra alla dessa funktioner för effektiv Kotlin-utveckling.

Flow och StateFlow

Flow — kall asynkron dataström i Kotlin. Avger värden på begäran av samlaren. StateFlow — het Flow med ett enda aktuellt värde. Används i ViewModel för UI State. SharedFlow — het Flow för händelser (engångshändelser). flowOf, asFlow — skapa Flow från samlingar. catch, retry, debounce — operatorer. stateIn, shareIn — konvertering av kall Flow till het. IT Sectr rekommenderar StateFlow för UI State och SharedFlow för händelser (Snackbar, navigering).

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

Serialisering (kotlinx.serialization, Parcelize)

kotlinx.serialization — Kotlin-bibliotek för JSON-serialisering. @Serializable — annotering. @SerialName — anpassat fältnamn. Stöder: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize för Android Parcelable (utan manuell implementering). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, kompileringssäker, utan reflektion. Moshi — annoteringar + codegen. IT Sectr rekommenderar kotlinx.serialization för nya projekt och Moshi för befintliga.

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

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