[Java] 独自の例外クラスを自作する方法をわかりやすく解説

Javaで独自の例外クラスを作成するには、ExceptionまたはRuntimeExceptionを継承します。

Exceptionを継承するとチェック例外、RuntimeExceptionを継承すると非チェック例外になります。

クラス内でコンストラクタを定義し、エラーメッセージや原因を渡せるようにします。

例えば、public class MyException extends Exceptionのように定義し、必要に応じてsuper(message)を使って親クラスのコンストラクタを呼び出します。

この記事でわかること

独自の例外クラスの作成方法
チェック例外と非チェック例外の違い
例外処理の重要性と活用法
業務ロジックに特化した例外の例
API開発でのエラーハンドリングの手法

目次から探す

独自の例外クラスを作成する理由

例外処理の重要性

例外処理は、プログラムの実行中に発生する予期しないエラーを適切に管理するための重要な手法です。

Javaでは、例外が発生すると、通常のプログラムの流れが中断されます。

これにより、プログラムがクラッシュするのを防ぎ、エラーの原因を特定しやすくします。

適切な例外処理を行うことで、ユーザーに対してより良い体験を提供し、システムの安定性を向上させることができます。

Javaの標準例外クラスの限界

Javaには多くの標準例外クラスが用意されていますが、これらは一般的なエラーに対処するためのものであり、特定のアプリケーションやビジネスロジックに特化したエラーには対応していません。

例えば、データベース接続エラーや特定のビジネスルールに違反した場合のエラーなど、標準の例外クラスでは十分に表現できないケースが多く存在します。

このような場合、独自の例外クラスを作成することで、より明確で意味のあるエラーメッセージを提供することが可能になります。

独自例外クラスのメリット

独自の例外クラスを作成することには、以下のようなメリットがあります。

スクロールできます

メリット	説明
明確なエラーメッセージ	特定のエラーに対して、わかりやすいメッセージを提供できる。
エラーの分類が容易	独自の例外クラスを使うことで、エラーの種類を明確に分類できる。
ビジネスロジックに特化	アプリケーションのビジネスルールに基づいたエラー処理が可能。
コードの可読性向上	独自の例外クラスを使用することで、コードの意図が明確になる。

これらのメリットを活かすことで、より堅牢でメンテナンスしやすいプログラムを構築することができます。

独自の例外クラスを作成することは、Javaプログラミングにおいて非常に有用な技術です。

独自の例外クラスの基本構造

ExceptionとRuntimeExceptionの違い

Javaでは、例外は主に2つのカテゴリに分けられます。

ExceptionとRuntimeExceptionです。

Exception: チェック例外と呼ばれ、コンパイル時に処理を強制されます。

これらの例外は、通常、プログラムの実行中に発生する可能性があるエラーを示します。

例えば、ファイルが見つからない場合や、ネットワーク接続の問題などです。

RuntimeException: 非チェック例外と呼ばれ、コンパイル時に処理を強制されません。

これらは、プログラムのロジックエラーや不正な操作によって発生するエラーを示します。

例えば、NullPointerExceptionやArrayIndexOutOfBoundsExceptionなどです。

チェック例外と非チェック例外の使い分け

チェック例外と非チェック例外は、使用する場面によって使い分ける必要があります。

スクロールできます

種類	説明	使用例
チェック例外	コンパイル時に処理を強制される。	ファイル操作、データベース接続
非チェック例外	コンパイル時に処理を強制されない。	プログラムのロジックエラー

一般的に、外部要因によって発生する可能性のあるエラーにはチェック例外を、プログラムのロジックに起因するエラーには非チェック例外を使用します。

独自例外クラスの基本的な作成手順

独自の例外クラスを作成する手順は以下の通りです。

ExceptionまたはRuntimeExceptionを継承するクラスを作成する。
コンストラクタを定義し、エラーメッセージや原因を受け取るようにする。
必要に応じて、追加のメソッドを定義する。

以下は、独自の例外クラスを作成するサンプルコードです。

// App.java
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
    
    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
    
    // 追加のメソッドを定義することも可能
}

コンストラクタのオーバーロード

独自の例外クラスでは、コンストラクタをオーバーロードすることで、異なる引数を受け取ることができます。

これにより、エラーメッセージや原因を柔軟に指定できるようになります。

上記のサンプルコードでは、2つのコンストラクタを定義しています。

1つ目のコンストラクタは、エラーメッセージのみを受け取ります。
2つ目のコンストラクタは、エラーメッセージと原因を受け取ります。

superを使った親クラスのコンストラクタ呼び出し

独自の例外クラスを作成する際、superキーワードを使用して親クラスのコンストラクタを呼び出すことが重要です。

これにより、親クラスで定義されたエラーメッセージや原因を適切に設定することができます。

上記のサンプルコードでは、super(message)やsuper(message, cause)を使用して、親クラスのコンストラクタを呼び出しています。

これにより、例外の情報が正しく伝達されます。

独自例外クラスの実装例

チェック例外の実装例

チェック例外は、コンパイル時に処理を強制される例外です。

以下は、ファイルが見つからない場合にスローされる独自のチェック例外クラスの実装例です。

// App.java
import java.io.FileNotFoundException;
public class FileMissingException extends Exception {
    public FileMissingException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
    
    public FileMissingException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
    
    public static void main(String[] args) {
        try {
            throw new FileMissingException("指定されたファイルが見つかりません。");
        } catch (FileMissingException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

指定されたファイルが見つかりません。

非チェック例外の実装例

非チェック例外は、コンパイル時に処理を強制されない例外です。

以下は、無効な引数が渡された場合にスローされる独自の非チェック例外クラスの実装例です。

// App.java
public class InvalidArgumentException extends RuntimeException {
    public InvalidArgumentException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
    
    public static void main(String[] args) {
        throw new InvalidArgumentException("無効な引数が渡されました。");
    }
}

Exception in thread "main" InvalidArgumentException: 無効な引数が渡されました。

カスタムメッセージを持つ例外クラス

独自の例外クラスにカスタムメッセージを持たせることで、エラーの詳細をより明確に伝えることができます。

以下は、カスタムメッセージを持つ例外クラスの実装例です。

// App.java
public class CustomMessageException extends Exception {
    public CustomMessageException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
    
    public static void main(String[] args) {
        try {
            throw new CustomMessageException("カスタムメッセージの例外が発生しました。");
        } catch (CustomMessageException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

カスタムメッセージの例外が発生しました。

例外の原因を保持する例外クラス

例外の原因を保持することで、エラーの発生元を特定しやすくなります。

以下は、原因を保持する独自の例外クラスの実装例です。

// App.java
public class CauseException extends Exception {
    public CauseException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
    
    public static void main(String[] args) {
        try {
            throw new NullPointerException("ヌルポインタ例外が発生しました。");
        } catch (NullPointerException e) {
            try {
                throw new CauseException("原因を保持する例外が発生しました。", e);
            } catch (CauseException ce) {
                System.out.println(ce.getMessage()); // エラーメッセージを表示
                System.out.println("原因: " + ce.getCause().getMessage()); // 原因を表示
            }
        }
    }
}

原因を保持する例外が発生しました。
原因: ヌルポインタ例外が発生しました。

例外クラスに独自メソッドを追加する

独自の例外クラスに独自メソッドを追加することで、エラーに関する追加情報を提供することができます。

以下は、独自メソッドを持つ例外クラスの実装例です。

// App.java
public class DetailedException extends Exception {
    private int errorCode; // エラーコードを保持するフィールド
    public DetailedException(String message, int errorCode) {
        super(message); // 親クラスのコンストラクタを呼び出す
        this.errorCode = errorCode; // エラーコードを設定
    }
    
    public int getErrorCode() { // エラーコードを取得するメソッド
        return errorCode;
    }
    
    public static void main(String[] args) {
        try {
            throw new DetailedException("詳細な例外が発生しました。", 404);
        } catch (DetailedException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
            System.out.println("エラーコード: " + e.getErrorCode()); // エラーコードを表示
        }
    }
}

詳細な例外が発生しました。
エラーコード: 404

これらの実装例を通じて、独自の例外クラスを作成する方法やその活用方法を理解することができます。

独自の例外クラスを使用することで、エラー処理をより柔軟かつ明確に行うことが可能になります。

独自例外クラスの活用方法

例外をスローする方法

独自の例外クラスを作成したら、次にそれをスローする方法を理解することが重要です。

例外をスローするには、throwキーワードを使用します。

以下は、独自の例外をスローする例です。

// App.java

class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

public class Example {
    public void checkValue(int value) throws CustomException {
        if (value < 0) {
            throw new CustomException("値は0以上でなければなりません。"); // 独自例外をスロー
        }
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.checkValue(-1); // 負の値を渡す
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

値は0以上でなければなりません。

例外をキャッチして処理する方法

スローされた例外は、try-catchブロックを使用してキャッチし、適切に処理することができます。

以下は、例外をキャッチして処理する例です。

// App.java

class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

public class Example {
    public void riskyMethod() throws CustomException {
        throw new CustomException("危険なメソッドでエラーが発生しました。"); // 独自例外をスロー
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.riskyMethod(); // メソッドを呼び出す
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

危険なメソッドでエラーが発生しました。

try-catch-finallyブロックでの使用例

try-catch-finallyブロックを使用することで、例外が発生してもリソースを適切に解放することができます。

以下は、finallyブロックを使用した例です。

// App.java

class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

public class Example {
    public void riskyMethod() throws CustomException {
        throw new CustomException("リスクのあるメソッドでエラーが発生しました。"); // 独自例外をスロー
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.riskyMethod(); // メソッドを呼び出す
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        } finally {
            System.out.println("リソースを解放します。"); // 最後に必ず実行される
        }
    }
}

リスクのあるメソッドでエラーが発生しました。
リソースを解放します。

throwsキーワードの使い方

throwsキーワードを使用することで、メソッドがスローする可能性のある例外を宣言することができます。

これにより、呼び出し元で例外を処理することが強制されます。

以下は、throwsを使用した例です。

// App.java

class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

public class Example {
    public void riskyMethod() throws CustomException {
        throw new CustomException("危険なメソッドでエラーが発生しました。"); // 独自例外をスロー
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.riskyMethod(); // メソッドを呼び出す
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

危険なメソッドでエラーが発生しました。

例外の再スローとその意図

例外を再スローすることで、上位のメソッドにエラーを伝達することができます。

再スローは、エラー処理を一元化するために有用です。

以下は、例外を再スローする例です。

// App.java

class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

public class Example {
    public void riskyMethod() throws CustomException {
        try {
            throw new CustomException("リスクのあるメソッドでエラーが発生しました。"); // 独自例外をスロー
        } catch (CustomException e) {
            System.out.println("エラーを処理します。");
            throw e; // 例外を再スロー
        }
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.riskyMethod(); // メソッドを呼び出す
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

エラーを処理します。
リスクのあるメソッドでエラーが発生しました。

これらの方法を活用することで、独自の例外クラスを効果的に使用し、エラー処理をより柔軟かつ明確に行うことができます。

実際のプロジェクトでの応用例

業務ロジックに特化した例外クラスの作成

業務ロジックに特化した独自例外クラスを作成することで、特定のビジネスルールに基づくエラーを明確に管理できます。

例えば、顧客の年齢が不正な場合にスローされる例外クラスを作成することが考えられます。

以下はその実装例です。

// App.java
public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
}
public class Customer {
    private int age;
    public void setAge(int age) throws InvalidAgeException {
        if (age < 0) {
            throw new InvalidAgeException("年齢は0以上でなければなりません。"); // 独自例外をスロー
        }
        this.age = age;
    }
    
    public static void main(String[] args) {
        Customer customer = new Customer();
        try {
            customer.setAge(-5); // 不正な年齢を設定
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage()); // エラーメッセージを表示
        }
    }
}

年齢は0以上でなければなりません。

API開発での独自例外クラスの活用

API開発においては、クライアントに対して明確なエラーメッセージを返すことが重要です。

独自の例外クラスを使用することで、エラーの種類に応じたレスポンスを提供できます。

以下は、APIでの独自例外クラスの使用例です。

// App.java
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
}
@RestController
public class UserController {
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable String id) {
        User user = findUserById(id); // ユーザーを検索
        if (user == null) {
            throw new ResourceNotFoundException("ユーザーが見つかりません。"); // 独自例外をスロー
        }
        return user;
    }
}

この例では、ユーザーが見つからない場合にResourceNotFoundExceptionをスローし、APIクライアントに適切なエラーメッセージを返します。

フレームワークやライブラリでの独自例外クラスの使用

フレームワークやライブラリを使用する際にも、独自の例外クラスを作成することで、エラー処理を一元化できます。

例えば、Springフレームワークを使用している場合、独自の例外を作成し、@ControllerAdviceを使ってグローバルにエラーハンドリングを行うことができます。

// App.java
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleResourceNotFound(ResourceNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage()); // エラーメッセージを返す
    }
}

このようにすることで、アプリケーション全体で一貫したエラーハンドリングが可能になります。

複数の独自例外クラスを使ったエラーハンドリングの設計

複数の独自例外クラスを使用することで、異なるエラーに対して適切な処理を行うことができます。

例えば、ユーザーの入力エラーやデータベースエラーなど、異なる種類のエラーに対してそれぞれ独自の例外クラスを作成し、エラーハンドリングを設計します。

// App.java
public class InputValidationException extends Exception {
    public InputValidationException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
}
public class DatabaseException extends Exception {
    public DatabaseException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
}
public class UserService {
    public void createUser(String username) throws InputValidationException, DatabaseException {
        if (username == null || username.isEmpty()) {
            throw new InputValidationException("ユーザー名は必須です。"); // 入力エラー
        }
        // データベース操作
        if (/* データベースエラーが発生した場合 */) {
            throw new DatabaseException("データベースエラーが発生しました。"); // データベースエラー
        }
    }
}

このように、異なるエラーに対して異なる例外クラスを使用することで、エラーハンドリングをより明確にし、メンテナンス性を向上させることができます。

独自例外クラスを活用することで、プロジェクトのエラー処理を効果的に管理することが可能になります。