Top Fehler von Anfängern in Kotlin: Wie man sie vermeidet

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Top Fehler von Anfängern in Kotlin: Wie man sie vermeidet und sauberen Code schreibt

Kotlin ist eine moderne, prägnante und sichere Sprache, die schnell an Popularität in der Welt der Android-Entwicklung und des Backends gewonnen hat. Allerdings führen ihre Flexibilität und syntaktischer Zucker Anfänger oft in die Irre. In diesem Artikel analysieren wir 4 typische Fehler, die Anfänger in Kotlin machen, und zeigen anhand von Codebeispielen, wie man sie behebt.

1. Ignorieren von null safety und falsche Verwendung des `!!`-Operators

Eine der Hauptfunktionen von Kotlin ist null safety. Aber viele Anfänger, die an Java gewöhnt sind, verwenden !! (not-null assertion operator) weiterhin gedankenlos. Das ist der direkte Weg zu einem NullPointerException.

Schlechtes Beispiel:

fun getUserName(user: User?): String {    return user!!.name // Wenn user == null, gibt es NPE}

Gutes Beispiel (sicherer Umgang mit nullable):

fun getUserNameSafe(user: User?): String {    return user?.name ?: "Unbekannter Benutzer"}

Verwenden Sie ?.let{}, ?: (Elvis-Operator) und ?.run{} für den sicheren Zugriff. Der !!-Operator ist nur in seltenen Fällen gerechtfertigt, wenn Sie zu 100% sicher sind, dass der Wert nicht null ist (z.B. in Tests).

2. Falsche Verwendung von sealed classes und when

Sealed classes sind ein mächtiges Werkzeug zur Modellierung eingeschränkter Hierarchien. Aber Anfänger vergessen oft, dass when bei der Arbeit mit sealed classes erschöpfend (exhaustive) sein muss. Oder sie verwenden umgekehrt else, wo es nicht nötig ist.

Schlechtes Beispiel (fehlender Zweig):

sealed class Result {    data class Success(val data: String) : Result()    data class Error(val message: String) : Result()}

fun handleResult(result: Result) {    when (result) {        is Result.Success -> println(result.data)        // Zweig für Error fehlt – es wird eine Warnung geben    }}

Gutes Beispiel (erschöpfendes when):

fun handleResultExhaustive(result: Result) {    when (result) {        is Result.Success -> println(result.data)        is Result.Error -> println(result.message)    }    // Der Compiler verlangt kein else, da alle Varianten abgedeckt sind}

Wenn Sie einen neuen Zweig zu einer sealed class hinzufügen, zeigt der Compiler an, wo das when aktualisiert werden muss. Das schützt den Code vor Fehlern während des Refactorings.

3. Missbrauch von Coroutinen: Start ohne Kontext und Ignorieren von structured concurrency

Coroutinen sind eine hervorragende Möglichkeit, mit Asynchronität zu arbeiten, aber Anfänger starten sie oft ohne den richtigen Kontext oder vergessen structured concurrency. Das führt zu Speicherlecks und unkontrollierten Hintergrundaufgaben.

Schlechtes Beispiel (globaler Scope und Kontextverlust):

fun loadData() {    GlobalScope.launch { // Schlecht! Lebt, solange die App lebt        val data = fetchData() // Kann nach dem Schließen der Activity ausgeführt werden        updateUI(data) // Fehler: UI wurde bereits zerstört    }}

Gutes Beispiel (structured concurrency mit viewModelScope):

class MyViewModel : ViewModel() {    fun loadData() {        viewModelScope.launch {            val data = fetchData()            updateUI(data) // Wird automatisch abgebrochen, wenn ViewModel bereinigt wird        }    }}

Verwenden Sie immer coroutineScope, viewModelScope oder einen eigenen CoroutineScope mit einem klaren Lebenszyklus. Vermeiden Sie GlobalScope im Production-Code.