MENU
  1. ホーム
  2. Kotlin
  3. KotlinでEnumを活用したカスタム例外処理の設計と実装ガイド

KotlinでEnumを活用したカスタム例外処理の設計と実装ガイド

Kotlin

Kotlinで例外処理を設計する際、標準的なtry-catch構文だけでなく、より効果的で管理しやすい手法が求められることがあります。特に、複数のエラー種別を扱うアプリケーションでは、エラーの種類ごとに異なる処理やメッセージを提供する必要があります。そこで役立つのがEnum（列挙型）を利用したカスタム例外処理です。

本記事では、KotlinにおいてEnumを活用して効率的なカスタム例外処理を設計する方法を解説します。基本的な例外処理の概念から、Enumを活用するメリット、実装方法、ユニットテスト、よくある問題とその解決策まで、具体例を交えながら分かりやすく説明します。Enumを活用することで、エラー管理がシンプルになり、コードの可読性や保守性が向上します。

Kotlinでより堅牢なアプリケーションを構築するために、ぜひこの記事を参考にしてください。

目次
  1. カスタム例外処理の必要性
    1. カスタム例外の利点
    2. Enumを利用する利便性
  2. Kotlinにおける基本的な例外処理
    1. 基本的なtry-catch構文
    2. finallyブロック
    3. 複数のcatchブロック
    4. 標準例外の限界
  3. Enumを活用するメリット
    1. エラーの種類を一元管理
    2. 型安全なエラーハンドリング
    3. 一貫性のあるエラーメッセージとコード
    4. 可読性と保守性の向上
    5. まとめ
  4. KotlinでEnumを用いたカスタム例外クラスの作成
    1. ステップ1: Enumでエラータイプを定義する
    2. ステップ2: カスタム例外クラスを作成する
    3. ステップ3: カスタム例外をスローする
    4. ステップ4: カスタム例外をキャッチして処理する
    5. 出力結果
    6. まとめ
  5. 実装例：Enumを利用したカスタム例外処理
    1. 1. エラータイプをEnumで定義する
    2. 2. カスタム例外クラスを作成する
    3. 3. カスタム例外をスローする関数
    4. 4. 例外を処理する
    5. 5. 実行結果
    6. 解説
    7. まとめ
  6. Enumによるエラーメッセージとエラーコードの管理
    1. Enumでエラーメッセージとエラーコードを定義する
    2. カスタム例外クラスにEnumを統合する
    3. エラーメッセージとコードを利用する例
    4. エラーをキャッチしてメッセージとコードを表示する
    5. 実行結果
    6. Enumを使うメリット
    7. まとめ
  7. カスタム例外処理のユニットテスト
    1. 1. 依存関係の設定
    2. 2. カスタム例外とエラータイプの定義
    3. 3. テストする関数
    4. 4. ユニットテストの作成
    5. 5. テストの解説
    6. 6. テスト実行結果
    7. まとめ
  8. よくある問題とその解決策
    1. 1. カスタム例外が多すぎて管理が煩雑になる
    2. 2. Enumの拡張が難しい
    3. 3. 例外の情報が不足する
    4. 4. 例外の処理が重複する
    5. 5. Enumでのメッセージ変更が難しい
    6. まとめ
  9. まとめ

カスタム例外処理の必要性


ソフトウェア開発において、例外処理はエラー発生時にプログラムの挙動を制御し、適切にリカバリを行うための重要な仕組みです。Kotlinにも標準的な例外処理がありますが、複雑なアプリケーションでは標準の例外だけでは対応しきれないケースがあります。

カスタム例外の利点

  1. エラーの明確化
    標準例外では具体的なエラー内容が分かりにくい場合がありますが、カスタム例外を使用すれば、エラーの種類を明確に定義できます。
  2. コードの可読性向上
    エラーの原因が明確になるため、コードを読む他の開発者にとって理解しやすくなります。
  3. 一貫性のあるエラーハンドリング
    カスタム例外を導入することで、エラーハンドリングの方法や出力メッセージに一貫性を持たせることができます。

Enumを利用する利便性


カスタム例外にEnumを利用することで、次のような利便性が得られます。

  • エラーコードやメッセージの一元管理：エラーコードやメッセージをEnumで定義すれば、管理がしやすくなります。
  • 型安全性の向上：Enumを使用することで、エラー種別を限定し、誤ったエラー処理を防げます。

カスタム例外処理は、アプリケーションのエラーハンドリングをシンプルかつ効率的にし、開発の品質を高めるために欠かせない手法です。

Kotlinにおける基本的な例外処理

Kotlinでは、標準的な例外処理としてtry-catch構文が提供されています。これにより、コード内で発生するエラーをキャッチし、適切な処理を行うことが可能です。

基本的なtry-catch構文


Kotlinでの例外処理は、以下のようなtry-catchブロックで行います。

fun divide(a: Int, b: Int): Int {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        println("エラー: ${e.message}")
        0 // エラー時のデフォルト値
    }
}

fun main() {
    val result = divide(10, 0)
    println("結果: $result")
}

この例では、0で割ろうとするとArithmeticExceptionが発生し、キャッチされてエラーメッセージが表示されます。

finallyブロック


finallyブロックは、例外が発生してもしなくても必ず実行されるコードを記述するために使います。

try {
    val file = File("example.txt")
    file.readText()
} catch (e: FileNotFoundException) {
    println("ファイルが見つかりません: ${e.message}")
} finally {
    println("処理が完了しました。")
}

複数のcatchブロック


複数の例外をキャッチしたい場合は、catchブロックを複数定義できます。

try {
    val numbers = listOf(1, 2, 3)
    println(numbers[5])
} catch (e: IndexOutOfBoundsException) {
    println("インデックスが範囲外です: ${e.message}")
} catch (e: Exception) {
    println("その他のエラー: ${e.message}")
}

標準例外の限界


標準の例外処理は便利ですが、エラーの種類や対応方法が複雑になると限界があります。そのため、より柔軟でわかりやすいエラーハンドリングのためにカスタム例外が必要となるのです。

次のセクションでは、Enumを活用してカスタム例外処理を設計する方法について解説します。

Enumを活用するメリット

Kotlinにおける例外処理でEnumを活用することは、複数のエラー種別を明確に管理し、効率的に処理するための強力な手法です。Enumを利用することで、エラー管理がシンプルかつ型安全になり、コードの保守性と可読性が向上します。

エラーの種類を一元管理


Enumを使用すると、エラーの種類を一つの場所に集約できます。これにより、エラー定義が明確になり、バラバラに管理する必要がなくなります。

enum class ErrorType(val message: String) {
    NETWORK_ERROR("ネットワークエラーが発生しました"),
    DATABASE_ERROR("データベースエラーが発生しました"),
    AUTHENTICATION_ERROR("認証エラーが発生しました")
}

型安全なエラーハンドリング


Enumを用いることで、エラー種別が限定されるため、誤ったエラー処理を防ぐことができます。型安全性が向上し、コンパイル時にエラーが検出されやすくなります。

fun handleError(error: ErrorType) {
    when (error) {
        ErrorType.NETWORK_ERROR -> println(error.message)
        ErrorType.DATABASE_ERROR -> println(error.message)
        ErrorType.AUTHENTICATION_ERROR -> println(error.message)
    }
}

一貫性のあるエラーメッセージとコード


Enumにエラーメッセージやエラーコードを持たせることで、エラーハンドリングに一貫性を保てます。

enum class ErrorType(val code: Int, val message: String) {
    NETWORK_ERROR(1001, "ネットワークエラーが発生しました"),
    DATABASE_ERROR(1002, "データベースエラーが発生しました"),
    AUTHENTICATION_ERROR(1003, "認証エラーが発生しました")
}

fun handleError(error: ErrorType) {
    println("エラーコード: ${error.code}, メッセージ: ${error.message}")
}

可読性と保守性の向上


エラーの種類がEnumで明示されているため、コードの可読性が高まり、後から修正や拡張がしやすくなります。新しいエラータイプを追加する場合も、Enumに新たな項目を追加するだけで済みます。

まとめ


Enumを活用することで、エラー管理が効率的になり、コードの品質が向上します。エラーの種類が明確化され、型安全性と一貫性が確保されるため、複雑なアプリケーションでも堅牢な例外処理が可能になります。

KotlinでEnumを用いたカスタム例外クラスの作成

Kotlinでカスタム例外処理を行う際に、Enumを活用するとエラー種別やメッセージを明確に管理でき、効率的な設計が可能です。ここでは、Enumを使ってカスタム例外クラスを作成する手順を紹介します。

ステップ1: Enumでエラータイプを定義する


まず、発生しうるエラーの種類をEnumで定義します。エラーコードやエラーメッセージを含めることで、詳細な情報を保持できます。

enum class ErrorType(val code: Int, val message: String) {
    INVALID_INPUT(1001, "入力が無効です"),
    NETWORK_FAILURE(1002, "ネットワーク接続に失敗しました"),
    DATABASE_ERROR(1003, "データベース操作中にエラーが発生しました")
}

ステップ2: カスタム例外クラスを作成する


次に、Exceptionクラスを継承してカスタム例外クラスを作成し、コンストラクタでEnumを受け取るようにします。

class CustomException(val errorType: ErrorType) : Exception(errorType.message) {
    override fun toString(): String {
        return "エラーコード: ${errorType.code}, メッセージ: ${errorType.message}"
    }
}

ステップ3: カスタム例外をスローする


特定の条件でエラーが発生した際に、カスタム例外をスローします。

fun validateInput(input: String) {
    if (input.isBlank()) {
        throw CustomException(ErrorType.INVALID_INPUT)
    }
}

fun fetchData() {
    throw CustomException(ErrorType.NETWORK_FAILURE)
}

ステップ4: カスタム例外をキャッチして処理する


try-catchブロックでカスタム例外をキャッチし、適切に処理します。

fun main() {
    try {
        validateInput("")
    } catch (e: CustomException) {
        println(e)
    }

    try {
        fetchData()
    } catch (e: CustomException) {
        println(e)
    }
}

出力結果

エラーコード: 1001, メッセージ: 入力が無効です  
エラーコード: 1002, メッセージ: ネットワーク接続に失敗しました

まとめ


このように、Enumを用いたカスタム例外クラスを作成することで、エラーの種類やメッセージを一元管理し、エラーハンドリングを効率的に行えます。コードがシンプルで可読性が高まり、保守しやすい設計が実現できます。

実装例：Enumを利用したカスタム例外処理

ここでは、KotlinでEnumを活用したカスタム例外処理の具体的な実装例を紹介します。エラータイプをEnumで管理し、エラー発生時に適切な処理を行う方法をステップごとに説明します。

1. エラータイプをEnumで定義する

まず、考えられるエラーの種類をErrorTypeとしてEnumに定義します。エラーコードとエラーメッセージを含めることで、エラー情報を明確にします。

enum class ErrorType(val code: Int, val message: String) {
    INVALID_INPUT(1001, "入力が無効です"),
    NETWORK_FAILURE(1002, "ネットワーク接続に失敗しました"),
    DATABASE_ERROR(1003, "データベース操作中にエラーが発生しました"),
    AUTHENTICATION_FAILED(1004, "認証に失敗しました")
}

2. カスタム例外クラスを作成する

Exceptionを継承し、ErrorTypeを受け取るカスタム例外クラスを作成します。

class CustomException(val errorType: ErrorType) : Exception(errorType.message) {
    override fun toString(): String {
        return "エラーコード: ${errorType.code}, メッセージ: ${errorType.message}"
    }
}

3. カスタム例外をスローする関数

エラーが発生しうる関数でカスタム例外をスローします。

fun validateUserInput(input: String) {
    if (input.isBlank()) {
        throw CustomException(ErrorType.INVALID_INPUT)
    }
}

fun fetchDataFromServer() {
    throw CustomException(ErrorType.NETWORK_FAILURE)
}

fun accessDatabase() {
    throw CustomException(ErrorType.DATABASE_ERROR)
}

4. 例外を処理する

try-catchブロックでカスタム例外をキャッチし、適切な処理を行います。

fun main() {
    try {
        validateUserInput("")
    } catch (e: CustomException) {
        println(e)
    }

    try {
        fetchDataFromServer()
    } catch (e: CustomException) {
        println(e)
    }

    try {
        accessDatabase()
    } catch (e: CustomException) {
        println(e)
    }
}

5. 実行結果

プログラムを実行すると、以下のようにエラーごとに異なるメッセージが表示されます。

エラーコード: 1001, メッセージ: 入力が無効です  
エラーコード: 1002, メッセージ: ネットワーク接続に失敗しました  
エラーコード: 1003, メッセージ: データベース操作中にエラーが発生しました

解説

  1. Enumの活用
  • エラータイプごとにコードとメッセージを定義し、エラーの種類を一元管理しています。
  1. カスタム例外クラス
  • CustomExceptionクラスは、ErrorTypeを引数に取り、エラー情報をわかりやすく提供します。
  1. エラー処理の一貫性
  • エラーが発生した際に統一されたフォーマットでエラー情報を出力し、問題の特定が容易になります。

まとめ

この実装例を参考にすることで、Kotlinのアプリケーションにおけるエラーハンドリングをシンプルで効率的に行えます。Enumを活用することで、エラーの種類やメッセージが明確化され、コードの可読性や保守性が大幅に向上します。

Enumによるエラーメッセージとエラーコードの管理

カスタム例外処理において、エラーメッセージやエラーコードを一元管理することは、エラーの特定と修正を効率化するために重要です。KotlinのEnumを活用することで、エラーの種類ごとにメッセージやコードを簡潔に管理できます。

Enumでエラーメッセージとエラーコードを定義する

以下は、エラーメッセージとエラーコードを含むErrorTypeの定義例です。

enum class ErrorType(val code: Int, val message: String) {
    INVALID_INPUT(1001, "入力が無効です"),
    NETWORK_FAILURE(1002, "ネットワーク接続に失敗しました"),
    DATABASE_ERROR(1003, "データベースエラーが発生しました"),
    AUTHENTICATION_FAILED(1004, "認証に失敗しました")
}
  • code：エラー識別用の一意の番号。
  • message：エラーが発生した際に表示するメッセージ。

カスタム例外クラスにEnumを統合する

エラータイプを持つカスタム例外クラスを作成します。

class CustomException(val errorType: ErrorType) : Exception(errorType.message) {
    override fun toString(): String {
        return "エラーコード: ${errorType.code}, メッセージ: ${errorType.message}"
    }
}

エラーメッセージとコードを利用する例

以下の関数は、特定のエラーが発生した場合にカスタム例外をスローします。

fun processInput(input: String) {
    if (input.isBlank()) {
        throw CustomException(ErrorType.INVALID_INPUT)
    }
}

fun fetchData() {
    throw CustomException(ErrorType.NETWORK_FAILURE)
}

fun authenticateUser(isAuthenticated: Boolean) {
    if (!isAuthenticated) {
        throw CustomException(ErrorType.AUTHENTICATION_FAILED)
    }
}

エラーをキャッチしてメッセージとコードを表示する

try-catchブロックを使って、エラー情報を処理します。

fun main() {
    try {
        processInput("")
    } catch (e: CustomException) {
        println(e)
    }

    try {
        fetchData()
    } catch (e: CustomException) {
        println(e)
    }

    try {
        authenticateUser(false)
    } catch (e: CustomException) {
        println(e)
    }
}

実行結果

エラーコード: 1001, メッセージ: 入力が無効です  
エラーコード: 1002, メッセージ: ネットワーク接続に失敗しました  
エラーコード: 1004, メッセージ: 認証に失敗しました

Enumを使うメリット

  1. 一元管理
  • エラーコードやメッセージをEnumで一箇所に集約できるため、管理が容易です。
  1. 可読性の向上
  • コード内でエラー種別を明示することで、どのエラーが発生するかが分かりやすくなります。
  1. 拡張性
  • 新しいエラータイプを追加する際、Enumに項目を追加するだけで済みます。
  1. 型安全性
  • Enumにより、予期しないエラー種別の使用を防げます。

まとめ

Enumを使ってエラーメッセージやエラーコードを管理することで、エラーハンドリングがシンプルになり、コードの保守性と拡張性が向上します。エラー情報が一元管理されるため、アプリケーションの品質向上に大きく貢献します。

カスタム例外処理のユニットテスト

Kotlinでカスタム例外処理を導入した場合、正しく動作しているかを確認するためにはユニットテストが欠かせません。ユニットテストを通じて、例外が適切にスローされ、期待通りのエラーメッセージやエラーコードが返ってくるかを検証します。

ここでは、JUnitを使ってカスタム例外処理のテストを行う方法を解説します。

1. 依存関係の設定

プロジェクトにJUnitを追加するには、build.gradle.ktsに以下の依存関係を追加します。

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0")
}

2. カスタム例外とエラータイプの定義

これまでのセクションで作成したカスタム例外とEnumを使用します。

enum class ErrorType(val code: Int, val message: String) {
    INVALID_INPUT(1001, "入力が無効です"),
    NETWORK_FAILURE(1002, "ネットワーク接続に失敗しました")
}

class CustomException(val errorType: ErrorType) : Exception(errorType.message)

3. テストする関数

例外をスローする関数を用意します。

fun validateInput(input: String) {
    if (input.isBlank()) {
        throw CustomException(ErrorType.INVALID_INPUT)
    }
}

fun fetchData() {
    throw CustomException(ErrorType.NETWORK_FAILURE)
}

4. ユニットテストの作成

JUnitで例外が正しくスローされるかをテストします。

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import kotlin.test.assertEquals

class CustomExceptionTest {

    @Test
    fun `test validateInput throws CustomException with INVALID_INPUT`() {
        val exception = assertThrows<CustomException> {
            validateInput("")
        }
        assertEquals(ErrorType.INVALID_INPUT, exception.errorType)
        assertEquals("入力が無効です", exception.message)
    }

    @Test
    fun `test fetchData throws CustomException with NETWORK_FAILURE`() {
        val exception = assertThrows<CustomException> {
            fetchData()
        }
        assertEquals(ErrorType.NETWORK_FAILURE, exception.errorType)
        assertEquals("ネットワーク接続に失敗しました", exception.message)
    }
}

5. テストの解説

  • assertThrows
    例外がスローされることを確認します。期待する例外の型を指定し、例外が発生した場合に捕捉します。
  • assertEquals
    捕捉した例外のerrorTypeやmessageが期待通りであることを検証します。

6. テスト実行結果

テストを実行すると、以下のように成功するはずです。

> Task :test

CustomExceptionTest > test validateInput throws CustomException with INVALID_INPUT PASSED  
CustomExceptionTest > test fetchData throws CustomException with NETWORK_FAILURE PASSED  

BUILD SUCCESSFUL

まとめ

カスタム例外処理のユニットテストを行うことで、例外が正しく処理されているかを確認できます。JUnitを使用すれば、エラータイプやメッセージが期待通りか簡単に検証でき、アプリケーションの品質を確保できます。

よくある問題とその解決策

KotlinでEnumを利用したカスタム例外処理を設計する際、よく発生する問題とその解決策を紹介します。これらを理解しておくことで、効率的で堅牢なエラーハンドリングが可能になります。

1. カスタム例外が多すぎて管理が煩雑になる

問題：エラーの種類が増えると、カスタム例外やEnumが多くなり、管理が煩雑になることがあります。

解決策：

  • エラータイプをカテゴリごとに分割することで管理を容易にします。
  • 共通のカスタム例外クラスを作成し、Enumの中でエラーカテゴリを明示する構造にします。
enum class ErrorType(val code: Int, val message: String) {
    INPUT_ERROR(1001, "入力エラー"),
    NETWORK_ERROR(2001, "ネットワークエラー"),
    DATABASE_ERROR(3001, "データベースエラー")
}

2. Enumの拡張が難しい

問題：新しいエラータイプやフィールドを追加したい場合、Enumの構造変更が難しくなることがあります。

解決策：

  • Enumにインターフェースを導入して柔軟性を高めます。
interface ErrorDetails {
    val code: Int
    val message: String
}

enum class ErrorType : ErrorDetails {
    INVALID_INPUT {
        override val code = 1001
        override val message = "無効な入力です"
    },
    NETWORK_FAILURE {
        override val code = 1002
        override val message = "ネットワークエラーが発生しました"
    }
}

3. 例外の情報が不足する

問題：カスタム例外にエラーの詳細情報が含まれておらず、デバッグやログ出力が難しい。

解決策：

  • カスタム例外に追加の詳細情報（例：原因や発生場所）を含めるようにします。
class CustomException(
    val errorType: ErrorType,
    val details: String? = null
) : Exception("${errorType.message}. 詳細: $details")

使用例：

throw CustomException(ErrorType.DATABASE_ERROR, "ユーザーID 123のデータ取得に失敗")

4. 例外の処理が重複する

問題：複数の場所で同じような例外処理が繰り返され、冗長になる。

解決策：

  • 共通の例外処理関数を作成し、処理を一元化します。
fun handleException(exception: CustomException) {
    println("エラーコード: ${exception.errorType.code}")
    println("メッセージ: ${exception.errorType.message}")
    exception.details?.let { println("詳細: $it") }
}

使用例：

try {
    validateInput("")
} catch (e: CustomException) {
    handleException(e)
}

5. Enumでのメッセージ変更が難しい

問題：エラーメッセージを動的に変更する必要があるが、Enumでは固定のメッセージしか設定できない。

解決策：

  • メソッドをEnumに追加して、引数を受け取ることで動的なメッセージを生成します。
enum class ErrorType {
    INVALID_INPUT {
        override fun getMessage(details: String) = "入力が無効です: $details"
    },
    NETWORK_FAILURE {
        override fun getMessage(details: String) = "ネットワークエラー: $details"
    };

    abstract fun getMessage(details: String): String
}

まとめ

カスタム例外処理で発生しやすい問題を事前に理解し、適切な解決策を導入することで、コードの可読性と保守性が向上します。Enumやカスタム例外を柔軟に設計し、効率的なエラーハンドリングを実現しましょう。

まとめ

本記事では、KotlinにおけるEnumを活用したカスタム例外処理の設計と実装方法について解説しました。カスタム例外処理が必要な理由から始め、Enumを用いるメリット、具体的な実装方法、ユニットテスト、さらにはよくある問題とその解決策まで、詳しく紹介しました。

  • Enumを活用することで、エラーの種類やメッセージ、コードを一元管理でき、コードの可読性と保守性が向上します。
  • カスタム例外クラスを作成することで、エラー処理の柔軟性が高まり、より明確なエラーハンドリングが可能になります。
  • ユニットテストを導入することで、カスタム例外処理が正しく機能しているかを検証でき、アプリケーションの品質を向上させます。

適切なエラーハンドリングは、アプリケーションの安定性とユーザーエクスペリエンスを大きく向上させます。ぜひ、Kotlinでの開発においてEnumを活用したカスタム例外処理を取り入れて、堅牢でメンテナンスしやすいコードを実現してください。

Kotlin
プログラミング 例外処理 ENUM Kotlin

コメント

コメントする

目次
  1. カスタム例外処理の必要性
    1. カスタム例外の利点
    2. Enumを利用する利便性
  2. Kotlinにおける基本的な例外処理
    1. 基本的なtry-catch構文
    2. finallyブロック
    3. 複数のcatchブロック
    4. 標準例外の限界
  3. Enumを活用するメリット
    1. エラーの種類を一元管理
    2. 型安全なエラーハンドリング
    3. 一貫性のあるエラーメッセージとコード
    4. 可読性と保守性の向上
    5. まとめ
  4. KotlinでEnumを用いたカスタム例外クラスの作成
    1. ステップ1: Enumでエラータイプを定義する
    2. ステップ2: カスタム例外クラスを作成する
    3. ステップ3: カスタム例外をスローする
    4. ステップ4: カスタム例外をキャッチして処理する
    5. 出力結果
    6. まとめ
  5. 実装例：Enumを利用したカスタム例外処理
    1. 1. エラータイプをEnumで定義する
    2. 2. カスタム例外クラスを作成する
    3. 3. カスタム例外をスローする関数
    4. 4. 例外を処理する
    5. 5. 実行結果
    6. 解説
    7. まとめ
  6. Enumによるエラーメッセージとエラーコードの管理
    1. Enumでエラーメッセージとエラーコードを定義する
    2. カスタム例外クラスにEnumを統合する
    3. エラーメッセージとコードを利用する例
    4. エラーをキャッチしてメッセージとコードを表示する
    5. 実行結果
    6. Enumを使うメリット
    7. まとめ
  7. カスタム例外処理のユニットテスト
    1. 1. 依存関係の設定
    2. 2. カスタム例外とエラータイプの定義
    3. 3. テストする関数
    4. 4. ユニットテストの作成
    5. 5. テストの解説
    6. 6. テスト実行結果
    7. まとめ
  8. よくある問題とその解決策
    1. 1. カスタム例外が多すぎて管理が煩雑になる
    2. 2. Enumの拡張が難しい
    3. 3. 例外の情報が不足する
    4. 4. 例外の処理が重複する
    5. 5. Enumでのメッセージ変更が難しい
    6. まとめ
  9. まとめ