0Pricing
Kotlin Academy · Leçon

Créer des classes d’exception personnalisées

Définissez des exceptions propres à votre domaine avec des messages et des propriétés explicites.

Créer des classes d’exception personnalisées est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Pourquoi créer des exceptions personnalisées ?

Les exceptions personnalisées expriment la signification métier : les appelants peuvent les intercepter précisément, obtenir des messages utiles et agir différemment selon leur type.

Exception personnalisée la plus simple

Dérivez de Exception — ou d’une sous-classe spécifique comme RuntimeException — et transmettez un message au constructeur parent.

class InvalidEmailException(message: String) : Exception(message)
fun main() {
    try {
        throw InvalidEmailException("missing @")
    } catch (e: InvalidEmailException) {
        println("caught: ${e.message}")
    }
}

Exception avec propriétés

Ajoutez des champs pour transmettre le contexte : statut HTTP, nom du champ, nombre de tentatives, etc.

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 avec cause

Transmettez une cause pour conserver l’exception d’origine dans la chaîne.

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

Exceptions vérifiées ou non vérifiées

Kotlin traite toutes les exceptions comme des exceptions non vérifiées — aucune déclaration throws n’est requise. Par convention, dérivez de 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 d’exceptions métier

Construisez une hiérarchie afin que les appelants puissent intercepter un type de base pour une gestion générale ou des sous-types spécifiques pour les cas particuliers.

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

Hiérarchie d’exceptions scellée

Pour les ensembles fermés de types d’erreurs, utilisez une hiérarchie sealed — les appelants peuvent gérer exhaustivement chaque 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")))
}

Convention de nommage

Terminez les noms de classes d’exception personnalisées par Exception ou Error pour plus de clarté. Utilisez le passé ou un nom (par exemple : 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) }
}

Documenter les exceptions

Utilisez KDoc @throws pour documenter les exceptions qu’une fonction peut lancer.

/**
 * @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) }
}

Éviter l’usage excessif des exceptions

Les exceptions sont réservées aux situations exceptionnelles. Pour les résultats attendus — entrée vide ou champ facultatif manquant — préférez les retours nullable, les types de résultat scellés ou les valeurs par défaut.

fun findUser(id: Int): String? = if (id == 1) "Alice" else null
fun main() {
    val name = findUser(42) ?: "(unknown)"
    println(name) // (unknown), no exception
}

Exemple pratique

Une exception personnalisée réaliste pour un client d’API fictif, avec un statut et un corps de réponse.

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

Vérification rapide

Quelle classe parente est la plus couramment utilisée pour définir une exception Kotlin propre au domaine ?

Récapitulatif

Les exceptions personnalisées expriment la signification métier. Dérivez de RuntimeException ou Exception ; ajoutez des propriétés pour le contexte ; conservez les causes ; construisez des hiérarchies pour regrouper les interceptions. Utilisez des exceptions scellées pour les ensembles fermés et préférez les types nullable ou de résultat lorsque les erreurs sont attendues.

Questions Fréquemment Posées

La leçon « Créer des classes d’exception personnalisées » est-elle gratuite ?

Oui — le texte complet de « Créer des classes d’exception personnalisées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer des classes d’exception personnalisées » ?

Définissez des exceptions propres à votre domaine avec des messages et des propriétés explicites. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Créer des classes d’exception personnalisées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. try/catch/finally comme expression
  2. Créer des classes d’exception personnalisées
  3. runCatching et Result
  4. Relancer des exceptions et chaînage des exceptions
← Retour à Kotlin Academy