Aangepaste exceptionklassen maken
Definieer domeinspecifieke exceptions met betekenisvolle berichten en properties.
Aangepaste exceptionklassen maken is een gratis Kotlin Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.
Waarom aangepaste uitzonderingen?
Aangepaste uitzonderingen leggen domeinbetekenis vast: aanroepers kunnen ze specifiek opvangen, krijgen bruikbare berichten en kunnen op basis van het type verschillend handelen.
De eenvoudigste aangepaste uitzondering
Maak een subklasse van Exception (of van een specifieke subklasse zoals RuntimeException) en geef een bericht door aan de bovenliggende constructor.
class InvalidEmailException(message: String) : Exception(message)
fun main() {
try {
throw InvalidEmailException("missing @")
} catch (e: InvalidEmailException) {
println("caught: ${e.message}")
}
}Uitzondering met eigenschappen
Voeg velden toe om context door te geven: HTTP-status, veldnaam, aantal nieuwe pogingen enzovoort.
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}")
}
}Uitzondering met oorzaak
Geef een cause door om de oorspronkelijke uitzondering in de keten te behouden.
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})")
}
}Gecontroleerd versus ongecontroleerd
Kotlin behandelt alle uitzonderingen als ongecontroleerd (een throws-declaratie is niet vereist). Maak volgens afspraak een subklasse van RuntimeException.
class ValidationException(field: String, message: String) :
RuntimeException("[$field] $message")
fun main() {
try {
throw ValidationException("age", "must be positive")
} catch (e: ValidationException) {
println(e.message)
}
}Hiërarchie van domeinuitzonderingen
Bouw een hiërarchie zodat aanroepers een basistype kunnen opvangen voor algemene afhandeling of specifieke subtypen voor bijzondere gevallen.
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}") }
}
}Verzegelde hiërarchie van uitzonderingen
Gebruik voor gesloten verzamelingen van fouttypen een sealed-hiërarchie — aanroepers kunnen elke variant volledig afhandelen.
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")))
}Naamgevingsconventie
Laat de namen van aangepaste uitzonderingsklassen eindigen op Exception of Error voor duidelijkheid. Gebruik de verleden tijd of een zelfstandig naamwoord (bijvoorbeeld NotFound, 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) }
}Uitzonderingen documenteren
Gebruik KDoc @throws om te documenteren welke uitzonderingen een functie kan opwerpen.
/**
* @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) }
}Gebruik uitzonderingen niet te vaak
Uitzonderingen zijn bedoeld voor uitzonderlijke situaties. Geef voor verwachte uitkomsten (lege invoer, ontbrekend optioneel veld) de voorkeur aan nullable retourwaarden, verzegelde resultaattypen of standaardwaarden.
fun findUser(id: Int): String? = if (id == 1) "Alice" else null
fun main() {
val name = findUser(42) ?: "(unknown)"
println(name) // (unknown), no exception
}Praktisch voorbeeld
Een realistische aangepaste uitzondering voor een fictieve API-client, met status en inhoud.
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}")
}
}Korte controle
Welke bovenliggende klasse wordt het vaakst gebruikt bij het definiëren van een domeinspecifieke Kotlin-uitzondering?
Samenvatting
Aangepaste uitzonderingen leggen domeinbetekenis vast. Maak een subklasse van RuntimeException of Exception; voeg eigenschappen toe voor context; behoud oorzaken; bouw hiërarchieën voor gegroepeerde afhandeling. Gebruik verzegelde uitzonderingen voor gesloten verzamelingen en geef de voorkeur aan nullable- of resultaattypen wanneer fouten verwacht zijn.
Leer Kotlin met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Aangepaste exceptionklassen maken” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Aangepaste exceptionklassen maken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.
Wat leer ik in “Aangepaste exceptionklassen maken”?
Definieer domeinspecifieke exceptions met betekenisvolle berichten en properties. Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Kotlin Academy te beginnen?
Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Aangepaste exceptionklassen maken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?
Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- try/catch/finally als expressie
- Aangepaste exceptionklassen maken
- runCatching en Result
- Exceptions opnieuw gooien en exception chaining