⚠️ Ausnahmebehandlung

📖 Was sind Ausnahmen?

Ausnahmen (Exceptions) sind Fehler, die während der Programmausführung auftreten. Wenn Sie Ausnahmen gut behandeln, läuft Ihr Programm stabil weiter, ohne anzuhalten!

💡 Grundlegendes try-catch

Grundlegende Verwendung

fun main() {
    try {
        val result = 10 / 0  // Fehler tritt auf!
        println(result)
    } catch (e: Exception) {
        println("Fehler aufgetreten: ${e.message}")
    }
    // Fehler aufgetreten: / by zero

    println("Programm läuft weiter!")
}

Behandlung spezifischer Ausnahmen

fun main() {
    try {
        val text = "abc"
        val number = text.toInt()  // NumberFormatException
    } catch (e: NumberFormatException) {
        println("Kann nicht in Zahl umgewandelt werden: ${e.message}")
    } catch (e: Exception) {
        println("Unbekannter Fehler: ${e.message}")
    }
}

finally

fun main() {
    try {
        println("Aufgabe gestartet")
        // Aufgabe ausführen
    } catch (e: Exception) {
        println("Fehler aufgetreten")
    } finally {
        println("Aufräumarbeiten (wird immer ausgeführt)")
    }
}

🎯 Praktische Beispiele

Sichere Zahlenkonvertierung

fun safeToInt(text: String): Int? {
    return try {
        text.toInt()
    } catch (e: NumberFormatException) {
        null
    }
}

fun main() {
    println(safeToInt("123"))   // 123
    println(safeToInt("abc"))   // null

    val age = safeToInt("25") ?: 0
    println("Alter: $age")
}

Datei-Lesen-Simulation

class FileReader {
    fun readFile(filename: String): String {
        if (filename.isEmpty()) {
            throw IllegalArgumentException("Dateiname ist leer")
        }
        if (!filename.endsWith(".txt")) {
            throw IllegalArgumentException("Nur Textdateien werden unterstützt")
        }
        return "Dateiinhalt: $filename"
    }
}

fun main() {
    val reader = FileReader()

    try {
        val content = reader.readFile("data.txt")
        println(content)
    } catch (e: IllegalArgumentException) {
        println("Fehler: ${e.message}")
    }

    try {
        reader.readFile("")
    } catch (e: IllegalArgumentException) {
        println("Fehler: ${e.message}")
        // Fehler: Dateiname ist leer
    }
}

Benutzereingabe-Validierung

data class User(val name: String, val age: Int)

fun createUser(name: String, age: Int): User {
    require(name.isNotBlank()) { "Name ist erforderlich" }
    require(age > 0) { "Alter muss positiv sein" }
    require(age < 150) { "Alter ist zu hoch" }

    return User(name, age)
}

fun main() {
    try {
        val user1 = createUser("Max Mustermann", 25)
        println(user1)

        val user2 = createUser("", 25)  // Fehler!
    } catch (e: IllegalArgumentException) {
        println("Validierung fehlgeschlagen: ${e.message}")
        // Validierung fehlgeschlagen: Name ist erforderlich
    }
}

API-Antwortverarbeitung

sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

fun divide(a: Int, b: Int): Result<Int> {
    return try {
        Result.Success(a / b)
    } catch (e: ArithmeticException) {
        Result.Error(e)
    }
}

fun main() {
    val result1 = divide(10, 2)
    when (result1) {
        is Result.Success -> println("Ergebnis: ${result1.data}")
        is Result.Error -> println("Fehler: ${result1.exception.message}")
    }

    val result2 = divide(10, 0)
    when (result2) {
        is Result.Success -> println("Ergebnis: ${result2.data}")
        is Result.Error -> println("Fehler: ${result2.exception.message}")
    }
}

🔍 Als Ausdruck verwenden

try als Wert

fun main() {
    val number = try {
        "123".toInt()
    } catch (e: NumberFormatException) {
        0  // Standardwert
    }

    println(number)  // 123

    val invalid = try {
        "abc".toInt()
    } catch (e: NumberFormatException) {
        -1
    }

    println(invalid)  // -1
}

Verkettung

fun safeDivide(a: Int, b: Int): Int? {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        null
    }
}

fun main() {
    val result = safeDivide(10, 2)
        ?.let { it * 2 }
        ?.let { it + 5 }
        ?: 0

    println(result)  // 15 (10/2 * 2 + 5)
}

🛡️ Sicheren Code schreiben

require vs check

fun processOrder(quantity: Int, price: Int) {
    // Eingabe-Validierung
    require(quantity > 0) { "Menge muss positiv sein" }
    require(price > 0) { "Preis muss positiv sein" }

    val total = quantity * price

    // Status-Validierung
    check(total < 1000000) { "Gesamtbetrag ist zu hoch" }

    println("Bestellung abgeschlossen: ${total}€")
}

fun main() {
    try {
        processOrder(10, 5000)  // Erfolg
        processOrder(-1, 5000)  // require schlägt fehl
    } catch (e: IllegalArgumentException) {
        println("Eingabefehler: ${e.message}")
    } catch (e: IllegalStateException) {
        println("Statusfehler: ${e.message}")
    }
}

checkNotNull

fun processName(name: String?) {
    val validName = checkNotNull(name) { "Name ist null" }
    println("Verarbeitung: $validName")
}

fun main() {
    try {
        processName("Max Mustermann")  // Erfolg
        processName(null)      // Fehler
    } catch (e: IllegalStateException) {
        println("Fehler: ${e.message}")
    }
}

runCatching

Eine praktische Methode ab Kotlin 1.3!

fun main() {
    // runCatching verwenden
    val result = runCatching {
        "123".toInt()
    }

    result
        .onSuccess { println("Erfolg: $it") }
        .onFailure { println("Fehler: ${it.message}") }

    // getOrNull
    val number = runCatching { "abc".toInt() }.getOrNull()
    println(number)  // null

    // getOrDefault
    val safe = runCatching { "abc".toInt() }.getOrDefault(0)
    println(safe)  // 0
}

🎯 Praktische Muster

Wiederholungslogik

fun <T> retry(times: Int, block: () -> T): T? {
    repeat(times) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            println("Versuch ${attempt + 1} fehlgeschlagen: ${e.message}")
            if (attempt == times - 1) throw e
        }
    }
    return null
}

fun main() {
    var count = 0

    try {
        val result = retry(3) {
            count++
            if (count < 3) {
                throw Exception("Noch nicht fertig")
            }
            "Erfolg!"
        }
        println(result)
    } catch (e: Exception) {
        println("Endgültig fehlgeschlagen")
    }
}

Ressourcen-Bereinigung

class Resource : AutoCloseable {
    init {
        println("Ressource erstellt")
    }

    fun use() {
        println("Ressource verwendet")
    }

    override fun close() {
        println("Ressource aufgeräumt")
    }
}

fun main() {
    try {
        Resource().use { resource ->
            resource.use()
            // close() wird automatisch aufgerufen
        }
    } catch (e: Exception) {
        println("Fehler aufgetreten")
    }
}

🤔 Häufig gestellte Fragen

F1. Wann verwende ich throw?

A: Wenn Sie explizit eine Ausnahme auslösen möchten!

fun validateAge(age: Int) {
    if (age < 0) {
        throw IllegalArgumentException("Alter kann nicht negativ sein")
    }
    if (age > 150) {
        throw IllegalArgumentException("Alter ist zu hoch")
    }
}

F2. Exception vs RuntimeException?

A: Kotlin unterscheidet nicht!

// Java unterscheidet checked/unchecked
// Kotlin behandelt alle als unchecked (throws-Deklaration nicht erforderlich)

fun divide(a: Int, b: Int): Int {
    return a / b  // throws-Deklaration nicht erforderlich!
}

F3. Benutzerdefinierte Ausnahmen?

A: Erben Sie von Exception!

class InvalidEmailException(message: String) : Exception(message)

fun validateEmail(email: String) {
    if (!email.contains("@")) {
        throw InvalidEmailException("Ungültige E-Mail: $email")
    }
}

fun main() {
    try {
        validateEmail("invalid")
    } catch (e: InvalidEmailException) {
        println(e.message)
    }
}

🎬 Zusammenfassung

Erstellen Sie stabile Programme mit Ausnahmebehandlung!

Wichtige Punkte:
✅ Ausnahmen mit try-catch behandeln
✅ Mit require/check validieren
✅ runCatching für einfache Verwendung
✅ Als Ausdruck Werte zurückgeben
✅ Aufräumarbeiten mit finally

Nächster Schritt: Lernen Sie in Datei-Ein-/Ausgabe, wie Sie mit Dateien arbeiten!