Benutzerdefinierte Exception-Klassen erstellen
Definieren Sie domänenspezifische Exceptions mit aussagekräftigen Nachrichten und Properties.
Benutzerdefinierte Exception-Klassen erstellen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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 benutzerdefinierte Exceptions?
Benutzerdefinierte Exceptions bilden die Domänenbedeutung ab: Aufrufer können sie gezielt abfangen, aussagekräftige Nachrichten erhalten und je nach Typ unterschiedlich reagieren.
Die einfachste benutzerdefinierte Exception
Leiten Sie eine Klasse von Exception oder einer spezifischen Unterklasse wie RuntimeException ab und übergeben Sie dem Superkonstruktor eine Nachricht.
class InvalidEmailException(message: String) : Exception(message)
fun main() {
try {
throw InvalidEmailException("missing @")
} catch (e: InvalidEmailException) {
println("caught: ${e.message}")
}
}Exception mit Eigenschaften
Fügen Sie Felder hinzu, um Kontext zu übermitteln: HTTP-Status, Feldname, Anzahl der Wiederholungsversuche usw.
class HttpError(
message: String,
val statusCode: Int
) : Exception(message)
fun main() {
try {
throw HttpError("Not Found", 404)
} catch (e: HttpError) {
println("HTTP ${e.statusCode}: ${e.message}")
}
}Exception mit Ursache
Übergeben Sie eine cause, um die ursprüngliche Exception in der Kette zu erhalten.
class DatabaseError(message: String, cause: Throwable) : Exception(message, cause)
fun main() {
try {
try { error("connection refused") }
catch (e: Throwable) { throw DatabaseError("query failed", e) }
} catch (e: DatabaseError) {
println("${e.message} (caused by: ${e.cause?.message})")
}
}Checked vs. Unchecked
Kotlin behandelt alle Exceptions als unchecked; eine throws-Deklaration ist nicht erforderlich. Leiten Sie Klassen konventionell von RuntimeException ab.
class ValidationException(field: String, message: String) :
RuntimeException("[$field] $message")
fun main() {
try {
throw ValidationException("age", "must be positive")
} catch (e: ValidationException) {
println(e.message)
}
}Hierarchie von Domänen-Exceptions
Bauen Sie eine Hierarchie auf, damit Aufrufer für eine allgemeine Behandlung einen Basistyp oder für Sonderfälle spezifische Untertypen abfangen können.
open class AppException(message: String) : RuntimeException(message)
class NotFoundException(what: String) : AppException("$what not found")
class UnauthorizedException : AppException("not authorized")
fun main() {
val errors = listOf(NotFoundException("user"), UnauthorizedException())
for (e in errors) {
try { throw e }
catch (e: AppException) { println("App error: ${e.message}") }
}
}Versiegelte Exception-Hierarchie
Verwenden Sie für abgeschlossene Mengen von Fehlertypen eine sealed-Hierarchie – Aufrufer können jede Variante vollständig behandeln.
sealed class ApiError(message: String) : RuntimeException(message) {
class Timeout : ApiError("timeout")
class NotFound(val id: String) : ApiError("not found: $id")
class ServerError(val status: Int) : ApiError("server returned $status")
}
fun describe(e: ApiError) = when (e) {
is ApiError.Timeout -> "request timed out"
is ApiError.NotFound -> "id ${e.id} missing"
is ApiError.ServerError -> "5xx: ${e.status}"
}
fun main() {
println(describe(ApiError.NotFound("user-42")))
}Namenskonvention
Beenden Sie die Namen benutzerdefinierter Exception-Klassen zur besseren Verständlichkeit mit Exception oder Error. Verwenden Sie die Vergangenheitsform oder ein Substantiv, etwa NotFound oder InvalidInput.
class InvalidInputException(msg: String) : RuntimeException(msg)
class UserNotFoundException(id: Int) : RuntimeException("user $id not found")
fun main() {
try { throw UserNotFoundException(7) }
catch (e: UserNotFoundException) { println(e.message) }
}Exceptions dokumentieren
Verwenden Sie KDoc @throws, um zu dokumentieren, welche Exceptions eine Funktion auslösen kann.
/**
* @throws InvalidEmailException if the email is malformed
*/
fun validate(email: String) {
if ("@" !in email) throw InvalidEmailException("missing @")
}
class InvalidEmailException(m: String) : RuntimeException(m)
fun main() {
try { validate("nope") }
catch (e: InvalidEmailException) { println(e.message) }
}Exceptions nicht übermäßig verwenden
Exceptions sind für außergewöhnliche Situationen gedacht. Für erwartete Ergebnisse wie leere Eingaben oder fehlende optionale Felder sollten Sie nullable Rückgabewerte, versiegelte Ergebnistypen oder Standardwerte bevorzugen.
fun findUser(id: Int): String? = if (id == 1) "Alice" else null
fun main() {
val name = findUser(42) ?: "(unknown)"
println(name) // (unknown), no exception
}Praxisbeispiel
Eine realistische benutzerdefinierte Exception für einen fiktiven API-Client mit Status und Body.
class ApiException(
message: String,
val statusCode: Int,
val responseBody: String
) : RuntimeException(message)
fun main() {
try {
throw ApiException("Bad Request", 400, "{\"error\":\"invalid\"}")
} catch (e: ApiException) {
println("[${e.statusCode}] ${e.message}: ${e.responseBody}")
}
}Kurztest
Welche Basisklasse wird beim Definieren einer domänenspezifischen Kotlin-Exception am häufigsten verwendet?
Zusammenfassung
Benutzerdefinierte Exceptions bilden die Domänenbedeutung ab. Leiten Sie sie von RuntimeException oder Exception ab, fügen Sie Eigenschaften für Kontext hinzu, bewahren Sie Ursachen und erstellen Sie Hierarchien für gruppierte catch-Klauseln. Verwenden Sie versiegelte Exceptions für abgeschlossene Mengen und bevorzugen Sie nullable oder Result-Typen, wenn Fehler erwartet sind.
Häufig gestellte Fragen
Ist die Lektion „Benutzerdefinierte Exception-Klassen erstellen“ kostenlos?
Ja — der vollständige Text von „Benutzerdefinierte Exception-Klassen erstellen“ 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 „Benutzerdefinierte Exception-Klassen erstellen“?
Definieren Sie domänenspezifische Exceptions mit aussagekräftigen Nachrichten und Properties. 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 2 von 4.
Wie lange dauert die Lektion „Benutzerdefinierte Exception-Klassen erstellen“?
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
- try/catch/finally als Ausdruck
- Benutzerdefinierte Exception-Klassen erstellen
- runCatching und Result
- Exceptions erneut auslösen und verketten