0Pricing
Kotlin Academy · Lektion

try/catch/finally als Ausdruck

Verwenden Sie try-catch als Ausdruck, um Werte aus fehleranfälligem Code zurückzugeben.

try/catch/finally als Ausdruck 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.

try ist ein Ausdruck

In Kotlin ist try/catch ein Ausdruck – er liefert einen Wert zurück. Der letzte Ausdruck im try- oder catch-Block ist das Ergebnis.

Grundlagen von try/catch

Schließen Sie Code, der eine Exception auslösen kann, in einen try-Block ein und behandeln Sie Exceptions in catch.

fun main() {
    try {
        val n = "abc".toInt()
        println(n)
    } catch (e: NumberFormatException) {
        println("Not a number: ${e.message}")
    }
}

try gibt einen Wert zurück

Weisen Sie das Ergebnis eines try/catch einer Variablen zu. Der Wert entspricht dem Ergebnis des jeweils passenden Blocks.

fun main() {
    val n: Int = try {
        "42".toInt()
    } catch (e: NumberFormatException) {
        -1
    }
    println(n) // 42
}

try im Funktionsrumpf

Sie können try als Rumpf einer Funktion mit Ausdrucksrumpf verwenden.

fun parseOrDefault(s: String, default: Int): Int = try {
    s.toInt()
} catch (e: NumberFormatException) {
    default
}
fun main() {
    println(parseOrDefault("42", 0))   // 42
    println(parseOrDefault("abc", 0))  // 0
}

Mehrere catch-Klauseln

Listen Sie mehrere catch-Klauseln für unterschiedliche Exception-Typen auf. Die erste Übereinstimmung greift.

fun main() {
    val result: String = try {
        val list = listOf(1)
        list[5].toString()
    } catch (e: IndexOutOfBoundsException) {
        "index out of bounds"
    } catch (e: Exception) {
        "other error"
    }
    println(result)
}

finally-Block

finally wird immer ausgeführt und dient der Bereinigung. Es beeinflusst den Rückgabewert des try-Ausdrucks NICHT.

fun main() {
    val n: Int = try {
        "42".toInt()
    } catch (e: NumberFormatException) {
        -1
    } finally {
        println("cleanup runs")
    }
    println("value = $n")
}

try mit mehreren Anweisungen

Verwenden Sie einen Block mit mehreren Anweisungen. Der Wert entspricht dem letzten Ausdruck.

fun main() {
    val result: String = try {
        val n = 10 / 2
        val s = "Result is $n"
        s.uppercase()
    } catch (e: Exception) {
        "ERROR"
    }
    println(result) // RESULT IS 5
}

Mehrere Typen abfangen

Kotlin unterstützt nicht die Multi-Catch-Syntax von Java (catch (A | B)). Verwenden Sie einen gemeinsamen Supertyp oder separate catch-Klauseln.

fun parse(s: String): Int = try {
    s.toInt()
} catch (e: RuntimeException) { // covers NumberFormatException etc.
    -1
}
fun main() {
    println(parse("42"))
    println(parse("nope"))
}

Die Reihenfolge von catch ist wichtig

Listen Sie spezifische Exceptions vor ihren Supertypen auf – andernfalls fängt der Supertyp die Exception zuerst ab.

fun main() {
    try {
        throw NumberFormatException("oops")
    } catch (e: NumberFormatException) {
        println("specific: ${e.message}")
    } catch (e: Exception) {
        println("generic")
    }
}

Aus try zurückkehren

Sie können innerhalb von try vorzeitig zurückkehren – der finally-Block wird trotzdem ausgeführt.

fun process(x: Int): String {
    return try {
        require(x > 0) { "must be positive" }
        "ok: $x"
    } catch (e: IllegalArgumentException) {
        "error: ${e.message}"
    } finally {
        println("processing done")
    }
}
fun main() {
    println(process(5))
    println(process(-1))
}

Anti-Pattern: Leeres catch

Leere catch-Blöcke verbergen Fehler. Protokollieren Sie die Exception zumindest oder lösen Sie sie erneut aus.

fun main() {
    try {
        "abc".toInt()
    } catch (e: NumberFormatException) {
        // BAD: silently swallow
    }
    println("continued")
}

Kurztest

Welchen Wert ergibt ein try/catch-Ausdruck in Kotlin?

Zusammenfassung

try/catch ist ein Ausdruck: Er liefert einen Wert zurück. Listen Sie spezifische Exceptions vor Supertypen auf, verwenden Sie finally zur Bereinigung und vermeiden Sie leere catch-Blöcke. Verwenden Sie try als Funktionsrumpf oder um im Fehlerfall einen Standardwert zuzuweisen.

Häufig gestellte Fragen

Ist die Lektion „try/catch/finally als Ausdruck“ kostenlos?

Ja — der vollständige Text von „try/catch/finally als Ausdruck“ 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 „try/catch/finally als Ausdruck“?

Verwenden Sie try-catch als Ausdruck, um Werte aus fehleranfälligem Code zurückzugeben. 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 „try/catch/finally als Ausdruck“?

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

  1. try/catch/finally als Ausdruck
  2. Benutzerdefinierte Exception-Klassen erstellen
  3. runCatching und Result
  4. Exceptions erneut auslösen und verketten
← Zurück zu Kotlin Academy