Creare classi di eccezioni personalizzate
Definisca eccezioni specifiche del dominio con messaggi e proprietà significativi.
Creare classi di eccezioni personalizzate è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.
Perché utilizzare eccezioni personalizzate?
Le eccezioni personalizzate esprimono il significato del dominio: i chiamanti possono intercettarle in modo specifico, ottenere messaggi utili e comportarsi diversamente in base al tipo.
La più semplice eccezione personalizzata
Estenda Exception (o una sottoclasse specifica come RuntimeException) e passi un messaggio al costruttore della superclasse.
class InvalidEmailException(message: String) : Exception(message)
fun main() {
try {
throw InvalidEmailException("missing @")
} catch (e: InvalidEmailException) {
println("caught: ${e.message}")
}
}Eccezione con proprietà
Aggiunga campi per fornire il contesto: stato HTTP, nome del campo, numero di tentativi e così via.
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}")
}
}Eccezione con causa
Passi una cause per preservare l'eccezione originale nella catena.
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})")
}
}Eccezioni checked e unchecked
Kotlin tratta tutte le eccezioni come unchecked (non è necessaria una dichiarazione throws). Per convenzione, estenda 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)
}
}Gerarchia delle eccezioni di dominio
Costruisca una gerarchia per consentire ai chiamanti di intercettare un tipo base per la gestione generale o sottotipi specifici per casi particolari.
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}") }
}
}Gerarchia di eccezioni sealed
Per insiemi chiusi di tipi di errore, utilizzi una gerarchia sealed: i chiamanti possono gestire in modo esaustivo ogni variante.
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")))
}Convenzione di denominazione
Termini i nomi delle classi di eccezioni personalizzate con Exception o Error per maggiore chiarezza. Utilizzi il passato o un sostantivo, ad esempio NotFound o 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) }
}Documentare le eccezioni
Utilizzi KDoc @throws per documentare le eccezioni che una funzione può lanciare.
/**
* @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) }
}Eviti l'uso eccessivo delle eccezioni
Le eccezioni sono destinate a situazioni eccezionali. Per gli esiti previsti, come un input vuoto o un campo facoltativo mancante, preferisca restituzioni nullable, tipi result sealed o valori predefiniti.
fun findUser(id: Int): String? = if (id == 1) "Alice" else null
fun main() {
val name = findUser(42) ?: "(unknown)"
println(name) // (unknown), no exception
}Esempio pratico
Un'eccezione personalizzata realistica per un client API fittizio, con stato e corpo della risposta.
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}")
}
}Verifica rapida
Quale classe padre viene utilizzata più comunemente quando si definisce un'eccezione Kotlin specifica del dominio?
Riepilogo
Le eccezioni personalizzate esprimono il significato del dominio. Estenda RuntimeException o Exception; aggiunga proprietà per il contesto; preservi le cause; costruisca gerarchie per raggruppare le intercettazioni. Utilizzi eccezioni sealed per insiemi chiusi e preferisca tipi nullable o result quando gli errori sono previsti.
Domande Frequenti
La lezione «Creare classi di eccezioni personalizzate» è gratuita?
Sì — il testo completo di «Creare classi di eccezioni personalizzate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.
Cosa imparerò in «Creare classi di eccezioni personalizzate»?
Definisca eccezioni specifiche del dominio con messaggi e proprietà significativi. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Kotlin Academy?
Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Creare classi di eccezioni personalizzate»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?
Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- try/catch/finally come espressione
- Creare classi di eccezioni personalizzate
- runCatching e Result
- Rilanciare eccezioni e concatenarle