MENU
  1. ホーム
  2. Kotlin
  3. Kotlinでカスタム例外クラスを作成する方法と実践ガイド

Kotlinでカスタム例外クラスを作成する方法と実践ガイド

Kotlin

Kotlinで例外処理を効果的にカスタマイズすることは、堅牢なプログラムを構築するために重要です。標準の例外クラスだけでは特定の状況に対応しきれない場合、独自のカスタム例外クラスを作成することで、エラーの種類や原因を明確にし、適切な処理を行えます。

本記事では、Kotlinにおけるカスタム例外クラスの作成方法と活用法を具体例を交えながら解説します。カスタム例外をスローする方法、捕捉・処理する手順、さらにはベストプラクティスまで網羅し、実践的な知識を提供します。

目次
  1. カスタム例外とは何か
    1. 標準例外との違い
    2. カスタム例外の活用シーン
  2. カスタム例外を作成する基本ステップ
    1. ステップ1: カスタム例外クラスの定義
    2. ステップ2: 例外をスローする
    3. ステップ3: 例外の捕捉と処理
    4. ステップ4: 追加情報を含める
  3. カスタム例外をスローする方法
    1. 基本的なスローの構文
    2. 具体例：入力検証でのカスタム例外スロー
    3. 条件に応じて異なるカスタム例外をスローする
    4. 例外をスローする際のポイント
  4. カスタム例外の捕捉と処理
    1. 基本的な`try-catch`構文
    2. 具体例：カスタム例外を捕捉する
    3. 複数の例外を捕捉する
    4. 共通の処理を行う場合
    5. `finally`ブロックで後処理
    6. まとめ
  5. 例外メッセージとデータのカスタマイズ
    1. カスタム例外に追加データを持たせる
    2. 具体例：エラーコードとエラーメッセージ
    3. エラー発生時の追加情報をログに記録
    4. データクラスを利用したカスタム例外
    5. まとめ
  6. 実践例：カスタム例外を用いたバリデーション
    1. カスタム例外クラスの定義
    2. バリデーション関数の作成
    3. カスタム例外の捕捉と処理
    4. 複数のエラーを収集するバリデーション
    5. バリデーションエラーの処理を効率化するポイント
    6. まとめ
  7. 複数のカスタム例外の管理
    1. 複数のカスタム例外クラスの定義
    2. 例外をスローする関数の作成
    3. 共通のエラーハンドリングロジック
    4. カスタム例外の基底クラスを作成
    5. エラーハンドリングのベストプラクティス
    6. まとめ
  8. 例外処理におけるベストプラクティス
    1. 1. 適切なカスタム例外クラスの作成
    2. 2. エラーメッセージに具体性を持たせる
    3. 3. 例外の捕捉は必要最低限に
    4. 4. 共通の基底クラスで例外を統一
    5. 5. `finally`ブロックを活用して後処理
    6. 6. ロギングを活用する
    7. 7. 例外を乱用しない
    8. 8. 例外の再スローを適切に行う
    9. まとめ
  9. まとめ

カスタム例外とは何か

Kotlinにおけるカスタム例外とは、開発者が独自に定義する例外クラスのことです。標準ライブラリにはIllegalArgumentExceptionやNullPointerExceptionなどの一般的な例外クラスが用意されていますが、特定のビジネスロジックや要件に合った例外を処理するには、カスタム例外が有効です。

標準例外との違い

標準例外は多くの場面で再利用できますが、具体的なエラー原因を示すには情報が不十分な場合があります。例えば、認証エラーやデータ不整合といった特定のシナリオでは、以下のようにカスタム例外が役立ちます。

  • 標準例外：IllegalArgumentException — 入力が無効であることのみを示す
  • カスタム例外：InvalidUserInputException — 入力がどのように無効なのかを明確に示す

カスタム例外の活用シーン

カスタム例外は、以下のようなシーンで活用できます。

  1. ビジネスロジックエラー：特定の業務ルール違反を明示的に示したい場合。
  2. 入力データのバリデーション：ユーザー入力の検証エラーを細かく分類したい場合。
  3. APIエラー処理：外部APIのエラーを特定し、適切に処理したい場合。

カスタム例外を活用することで、プログラムの可読性と保守性が向上し、エラー処理が直感的になります。

カスタム例外を作成する基本ステップ

Kotlinでカスタム例外クラスを作成するには、基本的に既存のExceptionクラスまたはRuntimeExceptionクラスを継承します。以下は、カスタム例外を作成するための手順です。

ステップ1: カスタム例外クラスの定義

以下の例では、InvalidInputExceptionというカスタム例外を定義しています。

class InvalidInputException(message: String) : Exception(message)
  • message: String: 例外に渡されるエラーメッセージ。
  • Exception: 親クラスとしてKotlin標準のExceptionを継承しています。

ステップ2: 例外をスローする

カスタム例外を作成したら、必要な箇所でthrowキーワードを使って例外をスローします。

fun validateInput(input: String) {
    if (input.isEmpty()) {
        throw InvalidInputException("入力が空です。正しい値を入力してください。")
    }
}

ステップ3: 例外の捕捉と処理

スローされたカスタム例外は、try-catchブロックで捕捉し、適切に処理します。

fun main() {
    try {
        validateInput("")
    } catch (e: InvalidInputException) {
        println("エラー: ${e.message}")
    }
}

ステップ4: 追加情報を含める

カスタム例外に追加のデータを渡したい場合、プロパティを追加できます。

class InvalidInputException(val errorCode: Int, message: String) : Exception(message)

fun validateAge(age: Int) {
    if (age < 0) {
        throw InvalidInputException(1001, "年齢が負の数です。")
    }
}

fun main() {
    try {
        validateAge(-5)
    } catch (e: InvalidInputException) {
        println("エラー [コード: ${e.errorCode}]: ${e.message}")
    }
}

このように、Kotlinでカスタム例外クラスを作成することで、エラー内容を詳細に伝え、効率的なエラーハンドリングが可能になります。

カスタム例外をスローする方法

Kotlinでカスタム例外をスローするには、throwキーワードを使用します。これにより、特定の条件に違反した際にカスタム例外を発生させ、適切にエラー処理が行えます。

基本的なスローの構文

カスタム例外をスローする基本的な構文は以下の通りです。

throw CustomException("エラーメッセージ")

CustomExceptionは、あらかじめ定義したカスタム例外クラスです。

具体例：入力検証でのカスタム例外スロー

以下は、入力検証で不正なデータが検出された場合にカスタム例外をスローする例です。

class InvalidUserInputException(message: String) : Exception(message)

fun validateUsername(username: String) {
    if (username.length < 5) {
        throw InvalidUserInputException("ユーザー名が短すぎます。5文字以上で入力してください。")
    }
}

fun main() {
    try {
        validateUsername("abc")
    } catch (e: InvalidUserInputException) {
        println("エラー: ${e.message}")
    }
}

出力例:

エラー: ユーザー名が短すぎます。5文字以上で入力してください。

条件に応じて異なるカスタム例外をスローする

条件によって異なるカスタム例外をスローすることも可能です。

class EmptyFieldException(message: String) : Exception(message)
class InvalidFormatException(message: String) : Exception(message)

fun validateEmail(email: String) {
    if (email.isEmpty()) {
        throw EmptyFieldException("メールアドレスが入力されていません。")
    }
    if (!email.contains("@")) {
        throw InvalidFormatException("メールアドレスの形式が不正です。")
    }
}

fun main() {
    try {
        validateEmail("invalid-email")
    } catch (e: EmptyFieldException) {
        println("エラー: ${e.message}")
    } catch (e: InvalidFormatException) {
        println("エラー: ${e.message}")
    }
}

出力例:

エラー: メールアドレスの形式が不正です。

例外をスローする際のポイント

  1. 意味のあるエラーメッセージを提供し、問題の原因を明確にする。
  2. 必要に応じて追加データを例外クラスに含める。
  3. 適切なタイミングでthrowを使い、早期にエラーを検出する。

このように、throwキーワードを用いることで、Kotlinにおけるカスタム例外を効果的にスローし、エラー処理を明確にできます。

カスタム例外の捕捉と処理

Kotlinでカスタム例外を捕捉して適切に処理するには、try-catchブロックを使用します。カスタム例外を捕捉することで、エラーに応じた柔軟な処理が可能になります。

基本的な`try-catch`構文

カスタム例外を捕捉するための基本的なtry-catchの構文は次の通りです。

try {
    // 例外が発生する可能性のあるコード
} catch (e: CustomException) {
    // カスタム例外を捕捉した際の処理
}

具体例：カスタム例外を捕捉する

以下は、InvalidAgeExceptionというカスタム例外を捕捉し、エラー処理を行う例です。

class InvalidAgeException(message: String) : Exception(message)

fun validateAge(age: Int) {
    if (age < 0) {
        throw InvalidAgeException("年齢が負の数です。正しい年齢を入力してください。")
    }
}

fun main() {
    try {
        validateAge(-5)
    } catch (e: InvalidAgeException) {
        println("エラー: ${e.message}")
    }
}

出力例:

エラー: 年齢が負の数です。正しい年齢を入力してください。

複数の例外を捕捉する

複数種類のカスタム例外や標準例外を捕捉する場合は、複数のcatchブロックを使用します。

class EmptyFieldException(message: String) : Exception(message)
class InvalidFormatException(message: String) : Exception(message)

fun validateEmail(email: String) {
    if (email.isEmpty()) {
        throw EmptyFieldException("メールアドレスが入力されていません。")
    }
    if (!email.contains("@")) {
        throw InvalidFormatException("メールアドレスの形式が不正です。")
    }
}

fun main() {
    try {
        validateEmail("")
    } catch (e: EmptyFieldException) {
        println("入力エラー: ${e.message}")
    } catch (e: InvalidFormatException) {
        println("形式エラー: ${e.message}")
    }
}

出力例:

入力エラー: メールアドレスが入力されていません。

共通の処理を行う場合

複数の例外で共通の処理を行う場合は、親クラスのExceptionで捕捉できます。

fun main() {
    try {
        validateEmail("")
    } catch (e: Exception) {
        println("エラーが発生しました: ${e.message}")
    }
}

`finally`ブロックで後処理

finallyブロックを使うことで、例外が発生したかどうかに関わらず、必ず実行される後処理を記述できます。

fun main() {
    try {
        validateEmail("invalid-email")
    } catch (e: Exception) {
        println("エラー: ${e.message}")
    } finally {
        println("処理が終了しました。")
    }
}

出力例:

エラー: メールアドレスの形式が不正です。
処理が終了しました。

まとめ

  • try-catch：例外を捕捉して処理する。
  • 複数のcatch：異なる例外ごとに処理を分ける。
  • finally：後処理を記述する。

これにより、Kotlinでカスタム例外を効果的に捕捉・処理し、堅牢なエラーハンドリングが実現できます。

例外メッセージとデータのカスタマイズ

カスタム例外を使う際に、エラーメッセージや追加データをカスタマイズすることで、エラーの詳細情報を明示的に伝えられます。これにより、デバッグやエラー処理がより効率的になります。

カスタム例外に追加データを持たせる

カスタム例外クラスにプロパティを追加して、エラーに関する追加情報を持たせることができます。例えば、エラーコードや発生時刻などを含めることが可能です。

class CustomException(
    val errorCode: Int,
    message: String
) : Exception(message)

具体例：エラーコードとエラーメッセージ

エラーコードやエラー内容をカスタム例外に含める具体例です。

class InvalidUserInputException(
    val errorCode: Int,
    message: String
) : Exception(message)

fun validateInput(input: String) {
    if (input.isEmpty()) {
        throw InvalidUserInputException(1001, "入力が空です。値を入力してください。")
    }
}

fun main() {
    try {
        validateInput("")
    } catch (e: InvalidUserInputException) {
        println("エラー [コード: ${e.errorCode}]: ${e.message}")
    }
}

出力例:

エラー [コード: 1001]: 入力が空です。値を入力してください。

エラー発生時の追加情報をログに記録

エラー発生時に例外オブジェクトのデータをログに記録することで、デバッグや診断が容易になります。

class DatabaseException(
    val errorCode: Int,
    val query: String,
    message: String
) : Exception(message)

fun fetchData(query: String) {
    throw DatabaseException(2001, query, "データベースクエリの実行に失敗しました。")
}

fun main() {
    try {
        fetchData("SELECT * FROM users")
    } catch (e: DatabaseException) {
        println("エラー [コード: ${e.errorCode}]: ${e.message}")
        println("問題のクエリ: ${e.query}")
    }
}

出力例:

エラー [コード: 2001]: データベースクエリの実行に失敗しました。
問題のクエリ: SELECT * FROM users

データクラスを利用したカスタム例外

Kotlinのデータクラスを使うことで、カスタム例外の宣言が簡潔になります。

data class ValidationException(val field: String, val errorMessage: String) : Exception(errorMessage)

fun validateUserName(userName: String) {
    if (userName.length < 5) {
        throw ValidationException("userName", "ユーザー名が短すぎます。5文字以上で入力してください。")
    }
}

fun main() {
    try {
        validateUserName("abc")
    } catch (e: ValidationException) {
        println("フィールド: ${e.field}, エラー: ${e.errorMessage}")
    }
}

出力例:

フィールド: userName, エラー: ユーザー名が短すぎます。5文字以上で入力してください。

まとめ

  • エラーメッセージのカスタマイズにより、エラー内容が明確になる。
  • 追加データ（エラーコードや発生時の情報）を含めることで、詳細なエラー情報を提供できる。
  • データクラスを利用すると、簡潔にカスタム例外を定義できる。

カスタム例外に詳細情報を含めることで、エラーのトラブルシューティングが効率的になり、システムの信頼性が向上します。

実践例：カスタム例外を用いたバリデーション

カスタム例外は、入力データのバリデーション（検証）に非常に役立ちます。適切なカスタム例外を使うことで、エラーの原因を明確にし、適切なエラーメッセージをユーザーに提示できます。

カスタム例外クラスの定義

まず、バリデーションエラー用のカスタム例外クラスを作成します。

class ValidationException(val field: String, message: String) : Exception(message)

この例外クラスには、エラーが発生したフィールド名とエラーメッセージを含めています。

バリデーション関数の作成

次に、ユーザー情報のバリデーション関数を作成します。名前、年齢、メールアドレスの入力を検証する例です。

fun validateUser(name: String, age: Int, email: String) {
    if (name.isEmpty()) {
        throw ValidationException("name", "名前が入力されていません。")
    }

    if (age <= 0) {
        throw ValidationException("age", "年齢は正の数である必要があります。")
    }

    if (!email.contains("@")) {
        throw ValidationException("email", "メールアドレスの形式が不正です。")
    }
}

カスタム例外の捕捉と処理

try-catchブロックでカスタム例外を捕捉し、エラーメッセージを出力します。

fun main() {
    try {
        validateUser("山田太郎", -1, "taro.yamadaexample.com")
    } catch (e: ValidationException) {
        println("エラー [${e.field}]: ${e.message}")
    }
}

出力例:

エラー [age]: 年齢は正の数である必要があります。

複数のエラーを収集するバリデーション

一度にすべてのエラーを収集したい場合、複数のカスタム例外をリストに追加する方法があります。

class ValidationException(val field: String, message: String) : Exception(message)

fun validateUserInputs(name: String, age: Int, email: String): List<ValidationException> {
    val errors = mutableListOf<ValidationException>()

    if (name.isEmpty()) {
        errors.add(ValidationException("name", "名前が入力されていません。"))
    }

    if (age <= 0) {
        errors.add(ValidationException("age", "年齢は正の数である必要があります。"))
    }

    if (!email.contains("@")) {
        errors.add(ValidationException("email", "メールアドレスの形式が不正です。"))
    }

    return errors
}

fun main() {
    val errors = validateUserInputs("", -5, "invalid-email")

    if (errors.isNotEmpty()) {
        for (error in errors) {
            println("エラー [${error.field}]: ${error.message}")
        }
    } else {
        println("すべての入力が正しいです。")
    }
}

出力例:

エラー [name]: 名前が入力されていません。
エラー [age]: 年齢は正の数である必要があります。
エラー [email]: メールアドレスの形式が不正です。

バリデーションエラーの処理を効率化するポイント

  1. エラーフィールドの特定: どのフィールドでエラーが発生したか明確にする。
  2. 複数エラーの収集: 複数のエラーを一度に報告し、ユーザーが修正しやすいようにする。
  3. カスタムメッセージ: エラー内容を具体的に伝えるメッセージを用意する。

まとめ

カスタム例外を用いたバリデーションは、入力データの検証を柔軟かつ明確に行うための強力な手段です。エラーの原因や対象フィールドを明示することで、ユーザーに分かりやすいエラーメッセージを提供でき、アプリケーションの使いやすさが向上します。

複数のカスタム例外の管理

Kotlinのアプリケーションでは、異なるエラー状況に対応するために、複数のカスタム例外を定義することが一般的です。これにより、エラー処理が明確になり、柔軟性が高まります。ここでは、複数のカスタム例外を効率的に管理する方法を解説します。

複数のカスタム例外クラスの定義

複数のシナリオに対応するために、異なるカスタム例外クラスを作成します。

// 入力に関連する例外
class EmptyFieldException(val field: String) : Exception("$field が空です。")

// データのフォーマットに関連する例外
class InvalidFormatException(val field: String, message: String) : Exception("$field: $message")

// 業務ロジックに関連する例外
class BusinessLogicException(message: String) : Exception("業務ロジックエラー: $message")

例外をスローする関数の作成

各関数で適切なカスタム例外をスローするようにします。

fun validateName(name: String) {
    if (name.isEmpty()) {
        throw EmptyFieldException("名前")
    }
}

fun validateEmail(email: String) {
    if (!email.contains("@")) {
        throw InvalidFormatException("メールアドレス", "正しい形式で入力してください。")
    }
}

fun processOrder(amount: Int) {
    if (amount <= 0) {
        throw BusinessLogicException("注文金額が無効です。")
    }
}

共通のエラーハンドリングロジック

複数のカスタム例外を効率的に処理するには、try-catchブロックを活用し、共通のエラーハンドリングロジックを作成します。

fun main() {
    try {
        validateName("")
        validateEmail("invalid-email")
        processOrder(-5)
    } catch (e: EmptyFieldException) {
        println("入力エラー: ${e.message}")
    } catch (e: InvalidFormatException) {
        println("フォーマットエラー: ${e.message}")
    } catch (e: BusinessLogicException) {
        println("業務エラー: ${e.message}")
    } catch (e: Exception) {
        println("その他のエラー: ${e.message}")
    }
}

出力例:

入力エラー: 名前 が空です。

カスタム例外の基底クラスを作成

すべてのカスタム例外を共通の基底クラスで管理すると、コードが整理され、例外処理が一元化できます。

open class ApplicationException(message: String) : Exception(message)

class EmptyFieldException(val field: String) : ApplicationException("$field が空です。")
class InvalidFormatException(val field: String, message: String) : ApplicationException("$field: $message")
class BusinessLogicException(message: String) : ApplicationException("業務ロジックエラー: $message")

fun main() {
    try {
        validateName("")
    } catch (e: ApplicationException) {
        println("アプリケーションエラー: ${e.message}")
    }
}

出力例:

アプリケーションエラー: 名前 が空です。

エラーハンドリングのベストプラクティス

  1. 基底クラスの活用: すべてのカスタム例外を共通の基底クラスで管理すると、例外処理が一元化できます。
  2. 意味のあるメッセージ: 例外に具体的なエラーメッセージやフィールド名を含めることで、デバッグや修正が容易になります。
  3. 特定の例外で捕捉: シナリオに応じて適切な例外を捕捉し、問題の種類に応じた処理を行いましょう。
  4. 共通ロジックの分離: 例外処理の共通ロジックは関数に分けて、再利用性を高めるとコードが整理されます。

まとめ

複数のカスタム例外を適切に管理することで、エラーの原因を明確にし、効率的なエラーハンドリングが可能になります。基底クラスを導入することで、コードの保守性と再利用性も向上します。

例外処理におけるベストプラクティス

Kotlinでカスタム例外を活用する際には、適切な設計と運用が重要です。例外処理のベストプラクティスを守ることで、コードの可読性、保守性、信頼性が向上します。ここでは、例外処理における効果的なベストプラクティスを紹介します。

1. 適切なカスタム例外クラスの作成

カスタム例外は、明確で具体的なエラーに対して作成しましょう。エラーの種類ごとに専用の例外クラスを定義すると、エラー処理が明確になります。

class InvalidInputException(message: String) : Exception(message)
class DatabaseException(message: String) : Exception(message)

2. エラーメッセージに具体性を持たせる

エラーメッセージは、問題の内容や解決方法を具体的に示すようにしましょう。これにより、デバッグや問題解決が容易になります。

throw InvalidInputException("ユーザー名が短すぎます。5文字以上で入力してください。")

3. 例外の捕捉は必要最低限に

すべての例外を捕捉するのではなく、特定のエラーだけを捕捉し、他の例外はシステム全体で処理するようにしましょう。

try {
    validateInput("test")
} catch (e: InvalidInputException) {
    println("入力エラー: ${e.message}")
}

4. 共通の基底クラスで例外を統一

複数のカスタム例外を共通の基底クラスで統一することで、効率的にエラーハンドリングが行えます。

open class ApplicationException(message: String) : Exception(message)

class InvalidInputException(message: String) : ApplicationException(message)
class DatabaseException(message: String) : ApplicationException(message)

fun handleError(e: ApplicationException) {
    println("アプリケーションエラー: ${e.message}")
}

5. `finally`ブロックを活用して後処理

finallyブロックを使うことで、エラーが発生しても必ず実行する後処理を記述できます。リソースの解放やクリーンアップ処理に有効です。

fun processFile() {
    val file = File("data.txt")
    try {
        file.readLines()
    } catch (e: IOException) {
        println("ファイル読み込みエラー: ${e.message}")
    } finally {
        println("処理が完了しました。")
    }
}

6. ロギングを活用する

エラーが発生した際には、例外をログに記録しましょう。ログにはエラーメッセージやスタックトレースを含めることで、問題の診断が容易になります。

fun logError(e: Exception) {
    println("エラーが発生しました: ${e.message}")
    e.printStackTrace()
}

fun main() {
    try {
        validateInput("")
    } catch (e: InvalidInputException) {
        logError(e)
    }
}

7. 例外を乱用しない

例外は本来、異常事態を示すために使うものです。通常の制御フロー（例：単純な条件分岐）には例外を使わないようにしましょう。

悪い例：

try {
    if (value < 0) throw Exception("負の数です。")
} catch (e: Exception) {
    println(e.message)
}

良い例：

if (value < 0) {
    println("負の数です。")
}

8. 例外の再スローを適切に行う

例外をキャッチした後、適切な場所で再スローすることで、上位の処理にエラー情報を伝えることができます。

fun validate(value: Int) {
    try {
        if (value < 0) throw InvalidInputException("負の数は無効です。")
    } catch (e: InvalidInputException) {
        println("検証エラー: ${e.message}")
        throw e  // 例外を再スロー
    }
}

まとめ

Kotlinでの例外処理のベストプラクティスを適用することで、エラー処理が効果的かつ効率的になります。具体的なエラーメッセージ、基底クラスの活用、適切なロギング、finallyブロックによる後処理などを意識して、堅牢なアプリケーションを構築しましょう。

まとめ

本記事では、Kotlinにおけるカスタム例外クラスの作成方法とその活用法について解説しました。カスタム例外を用いることで、エラーの種類や原因を明確にし、効果的なエラーハンドリングが可能になります。

特に以下のポイントを取り上げました：

  1. カスタム例外の基本概念と標準例外との違い。
  2. カスタム例外クラスの作成方法と追加データの管理。
  3. 例外のスローと捕捉・処理の手順。
  4. 実践例として、バリデーションでのカスタム例外の活用。
  5. ベストプラクティスを通して、効率的で信頼性の高い例外処理。

カスタム例外を正しく設計・実装することで、エラー処理が明確になり、コードの保守性や可読性が向上します。Kotlinを用いた開発で、カスタム例外を活用し、堅牢なアプリケーションを構築しましょう。

Kotlin
例外処理 カスタム例外 Kotlin

コメント

コメントする

目次
  1. カスタム例外とは何か
    1. 標準例外との違い
    2. カスタム例外の活用シーン
  2. カスタム例外を作成する基本ステップ
    1. ステップ1: カスタム例外クラスの定義
    2. ステップ2: 例外をスローする
    3. ステップ3: 例外の捕捉と処理
    4. ステップ4: 追加情報を含める
  3. カスタム例外をスローする方法
    1. 基本的なスローの構文
    2. 具体例：入力検証でのカスタム例外スロー
    3. 条件に応じて異なるカスタム例外をスローする
    4. 例外をスローする際のポイント
  4. カスタム例外の捕捉と処理
    1. 基本的な`try-catch`構文
    2. 具体例：カスタム例外を捕捉する
    3. 複数の例外を捕捉する
    4. 共通の処理を行う場合
    5. `finally`ブロックで後処理
    6. まとめ
  5. 例外メッセージとデータのカスタマイズ
    1. カスタム例外に追加データを持たせる
    2. 具体例：エラーコードとエラーメッセージ
    3. エラー発生時の追加情報をログに記録
    4. データクラスを利用したカスタム例外
    5. まとめ
  6. 実践例：カスタム例外を用いたバリデーション
    1. カスタム例外クラスの定義
    2. バリデーション関数の作成
    3. カスタム例外の捕捉と処理
    4. 複数のエラーを収集するバリデーション
    5. バリデーションエラーの処理を効率化するポイント
    6. まとめ
  7. 複数のカスタム例外の管理
    1. 複数のカスタム例外クラスの定義
    2. 例外をスローする関数の作成
    3. 共通のエラーハンドリングロジック
    4. カスタム例外の基底クラスを作成
    5. エラーハンドリングのベストプラクティス
    6. まとめ
  8. 例外処理におけるベストプラクティス
    1. 1. 適切なカスタム例外クラスの作成
    2. 2. エラーメッセージに具体性を持たせる
    3. 3. 例外の捕捉は必要最低限に
    4. 4. 共通の基底クラスで例外を統一
    5. 5. `finally`ブロックを活用して後処理
    6. 6. ロギングを活用する
    7. 7. 例外を乱用しない
    8. 8. 例外の再スローを適切に行う
    9. まとめ
  9. まとめ