Kotlin Academy · leksjon

Kaste exceptions på nytt og exception-kjeding

Kast exceptions på nytt ved behov, og pakk feil på lavere nivå inn med årsakskjeding.

Leksjon 4 av 413 trinn

Kaste exceptions på nytt og exception-kjeding er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Kaste på nytt og pakke inn

Noen ganger fanger De et unntak bare for å logge, pakke inn eller konvertere det før et mer spesifikt unntak får fortsette videre. Kotlin gjør dette på en idiomatisk måte.

Enkel videre kasting

For å kaste på nytt bruker De bare throw e igjen – videreføringen fortsetter til neste håndterer.

fun main() {
    try {
        try { "x".toInt() }
        catch (e: NumberFormatException) {
            println("logging: ${e.message}")
            throw e // re-throw original
        }
    } catch (e: NumberFormatException) {
        println("outer caught: ${e.message}")
    }
}

Pakke inn med et egendefinert unntak

Send det opprinnelige unntaket som cause når De oppretter et nytt, slik at kjeden bevares.

class ParseException(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun main() {
    try {
        try { "xyz".toInt() }
        catch (e: NumberFormatException) {
            throw ParseException("could not parse user input", e)
        }
    } catch (e: ParseException) {
        println("got: ${e.message}")
        println("cause: ${e.cause?.message}")
    }
}

Undersøke årsakskjeden

Egenskapen cause kobler til det forrige unntaket. Gå gjennom kjeden for å skrive ut hele rotårsaken.

fun main() {
    val e = RuntimeException("top",
        RuntimeException("middle",
            RuntimeException("root")))
    var current: Throwable? = e
    while (current != null) {
        println(current.message)
        current = current.cause
    }
}

Selektiv videre kasting

Fang en bred type, og kast den på nytt hvis den IKKE samsvarer med det forventede tilfellet.

fun parseRequired(s: String): Int {
    try {
        return s.toInt()
    } catch (e: NumberFormatException) {
        if (s.isBlank()) return 0
        throw e // unexpected — let it propagate
    }
}
fun main() {
    println(parseRequired("42"))
    println(parseRequired(""))
    // parseRequired("abc") // throws
}

Legge til kontekst

Pakk inn med et domenespesifikt unntak for å legge til kontekst som manglet i det opprinnelige unntaket (inndata, forespørsels-ID og så videre).

class UploadError(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun upload(file: String) {
    try { throw RuntimeException("disk full") }
    catch (e: Throwable) { throw UploadError("uploading $file failed", e) }
}
fun main() {
    try { upload("photo.jpg") }
    catch (e: UploadError) { println("${e.message} <- ${e.cause?.message}") }
}

Ikke mist stack trace

Når De pakker inn et unntak, må De alltid sende det opprinnelige som cause – opprett aldri bare et nytt unntak med samme melding, men uten årsak. Stack trace er livlinen ved feilsøking.

class Wrapped(m: String, cause: Throwable) : RuntimeException(m, cause)
fun main() {
    try {
        try { error("inner") }
        catch (e: Throwable) { throw Wrapped("outer", e) }
    } catch (e: Wrapped) {
        println("message: ${e.message}")
        println("cause: ${e.cause?.message}")
    }
}

Kaste på nytt uten innpakking

Hvis logging er alt De trenger, bruker De bare throw e etter loggekallet – innpakking er ikke nødvendig.

fun risky() {
    try { throw IllegalStateException("oops") }
    catch (e: IllegalStateException) {
        println("Logging before rethrow: ${e.message}")
        throw e
    }
}
fun main() {
    try { risky() }
    catch (e: IllegalStateException) { println("outer: ${e.message}") }
}

finally for opprydding ved ny kasting

Bruk finally til å rydde opp i ressurser, også når et unntak kastes på nytt.

fun process() {
    try {
        throw RuntimeException("failure")
    } finally {
        println("cleanup ran")
    }
}
fun main() {
    try { process() }
    catch (e: RuntimeException) { println("caught: ${e.message}") }
}

Undertrykte unntak

Hvis finally selv kaster et unntak, blir det opprinnelige unntaket som standard undertrykt. Bruk addSuppressed for å bevare begge.

fun main() {
    val primary = RuntimeException("primary")
    val secondary = RuntimeException("from cleanup")
    primary.addSuppressed(secondary)
    println(primary.suppressed.joinToString { it.message ?: "?" })
}

Antimønster: Undertrykke og deretter kaste et annet unntak

Å fange ett unntak og kaste et nytt, urelatert unntak (uten årsak) ødelegger feilsøkingsinformasjon. Send alltid med cause.

// BAD
// catch (e: IOException) { throw RuntimeException("error") }
// GOOD
// catch (e: IOException) { throw RuntimeException("error reading config", e) }
fun main() { println("Pass cause when re-throwing!") }

Hurtigsjekk

Når De pakker inn et unntak i et nytt, hva bør De gjøre for å bevare den opprinnelige stakksporingen?

Besvar den i den interaktive leksjonen

Oppsummering

For å kaste på nytt: throw e. For å pakke inn: kast et nytt unntak med cause = e. Bevar alltid årsakskjeden – konstruer aldri en innpakning uten årsak. Bruk finally til opprydding, og addSuppressed når selve oppryddingen mislykkes.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Kaste exceptions på nytt og exception-kjeding» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Kaste exceptions på nytt og exception-kjeding», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Kaste exceptions på nytt og exception-kjeding»?

Kast exceptions på nytt ved behov, og pakk feil på lavere nivå inn med årsakskjeding. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Kaste exceptions på nytt og exception-kjeding»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

try/catch/finally som et uttrykk
Opprette egendefinerte exception-klasser
runCatching og Result
Kaste exceptions på nytt og exception-kjeding

← Tilbake til Kotlin Academy