Kotlin Academy · Lektion

Nullable- und Non-Null-Typen

Grundlagen des Typsystems

Nullable- und Non-Null-Typen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Null-Sicherheit wichtig ist

Die berüchtigte NullPointerException hat unzählige Programme zum Absturz gebracht. Kotlin geht dieses Problem direkt an, indem es Nullbarkeit zu einem Bestandteil des Typsystems macht.

In Kotlin weiß der Compiler, ob ein Wert null sein kann oder nicht, und zwingt Sie, diese Möglichkeit zu behandeln, bevor Probleme auftreten.

Nicht-null-Typen

Standardmäßig ist jeder Typ in Kotlin nicht-null. Eine Variable vom Typ String kann niemals null enthalten.

Diese Garantie wird zur Compile-Zeit durchgesetzt, sodass Sie den Wert ohne Prüfungen verwenden können.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

Die Zuweisung von Null wird abgelehnt

Wenn Sie versuchen, null einem Nicht-null-Typ zuzuweisen, bricht der Compiler sofort ab.

Die folgende Zeile würde nicht kompiliert, weil String null nicht akzeptiert:

val name: String = null → Fehler

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Nullable-Typen

Um null zu erlauben, setzen Sie ein Fragezeichen hinter den Typ: String?.

Dies ist ein nullable Typ. Er kann entweder einen tatsächlichen Wert oder null enthalten.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Nullable im Vergleich zu Nicht-null

Die beiden Deklarationen sehen fast identisch aus, verhalten sich aber sehr unterschiedlich:

val a: String → niemals null
val b: String? → kann null sein

Das einzelne ? verändert den gesamten Vertrag der Variable.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

Der Compiler schützt den Zugriff auf Nullable-Werte

Sie können Methoden nicht direkt auf einem nullable Wert aufrufen. Der Compiler verweigert dies, weil der Wert null sein könnte.

Die auskommentierte Zeile unten würde nicht kompiliert:

maybe.length bei einem String? → Fehler

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Auf Null prüfen

Eine einfache Möglichkeit, einen nullable Wert zu verwenden, ist eine explizite if-Prüfung.

Innerhalb des if-Blocks weiß Kotlin, dass der Wert nicht null ist, und ermöglicht eine sichere Verwendung.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

Null in Funktionsparametern

Auch Parametertypen folgen dieser Regel. Ein Parameter vom Typ String muss einen tatsächlichen Wert erhalten, während String? null akzeptiert.

Dadurch ist anhand der Funktionssignatur unmittelbar erkennbar, welche Werte akzeptiert werden.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Nullable-Rückgabetypen

Funktionen können nullable Typen zurückgeben, um auszudrücken, dass ein Ergebnis fehlen kann.

Der Aufrufer muss dann das mögliche null behandeln, bevor er das Ergebnis verwendet.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Automatische Typinferenz

Wenn Sie ein Literal zuweisen, leitet Kotlin automatisch einen Nicht-null-Typ ab.

val n = "text" → abgeleitet als String

Damit der Typ nullable ist, müssen Sie ihn explizit mit ? deklarieren.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Alles zusammenführen

Das Typsystem teilt Werte in zwei klare Gruppen auf:

Nicht-null: immer sicher verwendbar
Nullable: muss vor der Verwendung behandelt werden

Diese Unterscheidung verschiebt Nullfehler von Abstürzen zur Laufzeit zu Fehlern zur Compile-Zeit.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Kurzer Test

Prüfen Sie Ihr Verständnis von nullable und Nicht-null-Typen.

Zusammenfassung

Sie haben die Grundlagen der Null-Sicherheit in Kotlin kennengelernt:

Jeder Typ ist standardmäßig nicht-null
Durch das Hinzufügen von ? entsteht ein nullable Typ
Der Compiler verhindert unsicheren Zugriff auf nullable Werte
Mit einer if (x != null)-Prüfung können Sie den Wert sicher verwenden

Als Nächstes lernen Sie die prägnanten Operatoren kennen, die die Arbeit mit nullable Werten mühelos machen.

Häufig gestellte Fragen

Ist die Lektion „Nullable- und Non-Null-Typen“ kostenlos?

Ja — der vollständige Text von „Nullable- und Non-Null-Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Nullable- und Non-Null-Typen“?

Grundlagen des Typsystems Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Nullable- und Non-Null-Typen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy