0Pricing
Kotlin Academy · Lekcja

try/catch/finally jako wyrażenie

Używaj try-catch jako wyrażenia zwracającego wartości z kodu podatnego na błędy.

try/catch/finally jako wyrażenie to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

try jako wyrażenie

W Kotlinie try/catch jest wyrażeniem — zwraca wartość. Wynikiem jest ostatnie wyrażenie w bloku try lub catch.

Podstawy try/catch

Umieść kod, który może zgłosić wyjątek, w bloku try; obsłuż wyjątki w bloku catch.

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

try zwraca wartość

Przypisz wynik wyrażenia try/catch do zmiennej. Wartość jest tym, co zwróci pasujący blok.

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

try jako treść funkcji

Możesz użyć try jako treści funkcji zapisanej w postaci wyrażenia.

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
}

Wiele klauzul catch

Wymień wiele klauzul catch dla różnych typów wyjątków. Użyta zostanie pierwsza pasująca klauzula.

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

Blok finally

finally jest zawsze wykonywany — służy do sprzątania. NIE wpływa na wartość zwracaną przez wyrażenie try.

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

try z wieloma instrukcjami

Użyj bloku zawierającego wiele instrukcji; wartością jest ostatnie wyrażenie.

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
}

Przechwytywanie wielu typów

Kotlin nie obsługuje składni multi-catch z Javy (catch (A | B)). Użyj wspólnego nadtypu albo osobnych klauzul catch.

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

Kolejność klauzul catch ma znaczenie

Umieszczaj konkretne wyjątki przed ich nadtypami — w przeciwnym razie nadtyp przechwyci wyjątek jako pierwszy.

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

Zwracanie z try

Możesz wcześniej zwrócić wartość z wnętrza try — blok finally nadal zostanie wykonany.

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

Antywzorzec: pusty catch

Puste bloki catch ukrywają błędy. Co najmniej zarejestruj wyjątek w dzienniku albo zgłoś go ponownie.

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

Szybkie sprawdzenie

Jaki wynik daje w Kotlinie wyrażenie try/catch?

Podsumowanie

try/catch jest wyrażeniem: zwraca wartość. Umieszczaj konkretne wyjątki przed ich nadtypami, używaj finally do sprzątania i unikaj pustych bloków catch. Możesz używać go jako treści funkcji albo do przypisywania wartości domyślnej w razie błędu.

Często zadawane pytania

Czy lekcja „try/catch/finally jako wyrażenie” jest bezpłatna?

Tak — pełny tekst „try/catch/finally jako wyrażenie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „try/catch/finally jako wyrażenie”?

Używaj try-catch jako wyrażenia zwracającego wartości z kodu podatnego na błędy. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „try/catch/finally jako wyrażenie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. try/catch/finally jako wyrażenie
  2. Tworzenie własnych klas wyjątków
  3. runCatching i Result
  4. Ponowne rzucanie wyjątków i ich łańcuchowanie
← Powrót do Kotlin Academy