Kotlin-Spezifika in der mobilen Entwicklung: was es ist, welche Konstrukte und wie es funktioniert

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

Kotlin erweitert die Klassenkonzepte von Java. data class, sealed class, object und companion object — Konstrukte, die es in Java nicht gibt oder anders implementiert sind.

data class vs sealed class

data class — eine Klasse, die automatisch equals(), hashCode(), toString(), copy() und componentN() generiert. Ideal für Datenmodelle (DTO, Entity). Anforderungen: mindestens ein Parameter im primären Konstruktor, val/var, kann nicht open/sealed/inner sein. sealed class — eine Klasse mit einer eingeschränkten Unterklassenhierarchie. Alle Unterklassen sind zur Kompilierzeit bekannt und in derselben Datei deklariert. Der when-Ausdruck mit sealed class benötigt keinen else-Zweig. sealed interface (Kotlin 1.9+) — wie sealed class, erlaubt aber Mehrfachvererbung. object — ein Singleton, mit dem Schlüsselwort object (nicht class) deklariert. Thread-sichere lazy-Initialisierung. companion object — statische Member einer Klasse. Hat einen Namen (standardmäßig Companion). Kann Schnittstellen implementieren und extension functions haben.

data class — für 90% der Modelle. sealed class — für UI State und Ergebnis. object — für Singletons. IT Sectr empfiehlt sealed class für alle Bildschirmzustände (Loading, Success, Error).

Sealed class in der Praxis

Sealed class — ein mächtiges Werkzeug zur Modellierung von Zuständen. Beispiel: UiState<T> mit Unterklassen Loading, Success(data: T), Error(message: String). Der when-Ausdruck garantiert die Behandlung aller Zustände. Sealed interface — für Ereignisse und Aktionen, bei denen Mehrfachimplementierung erforderlich ist. Value class (Kotlin 1.5+) — ein Wrapper für einen einzelnen Wert ohne Overhead. Wird für typsichere Identifikatoren verwendet: @JvmInline value class UserId(val id: String).

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

Extension Function — Hinzufügen einer Methode zu einer bestehenden Klasse ohne Vererbung. fun String.isEmail(): Boolean. Extension Property — dasselbe für Eigenschaften (ohne Backing-Field). Inline Function — Einfügen des Funktionskörpers an der Aufrufstelle — ohne Aufruf-Overhead. Wird für higher-order-Funktionen mit Lambdas verwendet. Higher-Order Function — eine Funktion, die eine andere Funktion entgegennimmt oder zurückgibt. Scope Functions — fünf Funktionen zur Arbeit mit dem Objektkontext: let, run, with, apply, also.

Scope Functions

let — Kontext it, gibt Lambda-Ergebnis zurück. Wird für null-sichere Aufrufe verwendet (?.let {}). apply — Kontext this, gibt Kontext zurück. Für Objektkonfiguration. run — Kontext this, gibt Lambda-Ergebnis zurück. Für Berechnungen mit Kontext. also — Kontext it, gibt Kontext zurück. Für Nebeneffekte (Logging). with — kein Extension, Kontext this, gibt Lambda-Ergebnis zurück. Für eine Gruppe von Operationen auf einem Objekt. Lambda — anonyme Funktion. Destructuring Declaration — Entpacken einer data class in Variablen: val (name, age) = person.

Inline + reified

Inline function mit reified — die einzige Möglichkeit, einen generischen Typ in der JVM zu erhalten. Verwendung für: typsichere Builder (Gson.fromJson<T>()), Typprüfung (is T), Abrufen der Klasse (T::class). Crossinline und Noinline — Modifikatoren für Lambda-Parameter in inline-Funktionen. crossinline — verbietet non-local return, noinline — verbietet das Inlining einer bestimmten Lambda. IT Sectr empfiehlt inline + reified nur bei der Arbeit mit Typen; für normale higher-order-Funktionen kann inline die Bytecode-Größe erhöhen.

Koroutinen (Coroutine Builder, Dispatchers, Scope)

Koroutinen — leichtgewichtige Threads für asynchrone Programmierung. Sie blockieren den Thread nicht — sie pausieren (suspend). suspend function — eine Funktion, die pausiert werden kann, ohne den Thread zu blockieren. Kann nur von einer Koroutine oder einer anderen suspend function aufgerufen werden.

CoroutineScope

CoroutineScope — ein Gültigkeitsbereich für Koroutinen. Enthält CoroutineContext (Job + Dispatcher). lifecycleScope — für Activity/Fragment (Lifecycle-bewusst). viewModelScope — für ViewModel (automatische Stornierung bei onCleared()). GlobalScope — globaler Scope (nicht für die Produktion empfohlen — Speicherlecks). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (Netzwerk/Disk), Dispatchers.Default (CPU-intensiv), Dispatchers.Unconfined (nicht empfohlen). launch — startet eine Koroutine: Job. async — startet mit Ergebnis: Deferred<T>. runBlocking — blockierende Brücke. withContext — wechselt den Dispatcher innerhalb einer suspend function.

// Beispiel Koroutinen: Daten laden im 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)
            }
        }
    }
}

// Parallele Anfragen mit 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 einer Koroutine im ViewModel. withContext(Dispatchers.IO) — Wechsel zum IO-Thread für Netzwerkanfragen. Dispatchers bestimmen, auf welchem Thread-Pool die Koroutine ausgeführt wird. IT Sectr empfiehlt viewModelScope für ViewModel und lifecycleScope für Activity/Fragment.

Fortgeschrittene Funktionen (reified, destructuring, lateinit/lazy)

reified — ein Typmodifikator in inline-Funktionen. Ermöglicht die Verwendung des Typs: T::class, is T, as T. Ohne reified werden Generics in der JVM gelöscht (Type Erasure). inline fun + reified — eine mächtige Kombination für typsichere APIs. Destructuring Declaration — val (x, y) = point. Funktioniert für data class und Typen mit componentN(). typealias — Typalias: typealias Callback = (String) -> Unit. lateinit — verzögerte Initialisierung von var (für Dependency Injection). Nicht threadsicher. lazy — lazy-Initialisierung von val (standardmäßig threadsicher). lazy(LazyThreadSafetyMode.NONE) — ohne Synchronisation. Extension function und Extension property — Hinzufügen von Funktionalität ohne Vererbung. Kotlin ist eine Sprache, in der extension functions 90% der Hilfsaufgaben lösen.

Delegierte Eigenschaften

Delegated Properties — Delegieren von Getter/Setter an ein anderes Objekt. Standarddelegaten: lazy, observable, vetoable, map. Benutzerdefinierter Delegat über getValue/setValue-Operatoren. by — Delegationsschlüsselwort: val name by lazy { loadName() }. Delegierte Eigenschaften sind die Grundlage für ViewModel-Delegaten (by viewModels()). IT Sectr empfiehlt lazy für verzögerte Initialisierung und Delegates.observable für die Beobachtung von Änderungen.

reified — für typsichere APIs. lazy — für verzögertes Laden. delegated properties — zur Wiederverwendung von Eigenschaftslogik. IT Sectr empfiehlt, alle diese Funktionen für eine effektive Kotlin-Entwicklung zu beherrschen.

Flow und StateFlow

Flow — kalter asynchroner Datenstrom in Kotlin. Gibt Werte auf Anfrage des Kollektors aus. StateFlow — heißer Flow mit einem einzigen aktuellen Wert. Wird im ViewModel für UI State verwendet. SharedFlow — heißer Flow für Ereignisse (Einmal-Ereignisse). flowOf, asFlow — Erstellung von Flow aus Sammlungen. catch, retry, debounce — Operatoren. stateIn, shareIn — Konvertierung von kaltem zu heißem Flow. IT Sectr empfiehlt StateFlow für UI State und SharedFlow für Ereignisse (Snackbar, Navigation).

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

Serialisierung (kotlinx.serialization, Parcelize)

kotlinx.serialization — Kotlin-Bibliothek für JSON-Serialisierung. @Serializable — Annotation. @SerialName — benutzerdefinierter Feldname. Unterstützt: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize für Android Parcelable (ohne manuelle Implementierung). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, kompilierungssicher, ohne Reflection. Moshi — Annotationen + Codegen. IT Sectr empfiehlt kotlinx.serialization für neue Projekte und Moshi für bestehende.

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

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