[Java] try-catchでcatch内で例外をスローするとどうなる？

Javaでtry-catch構文を使用し、catchブロック内で例外を再スローthrowすると、その例外は呼び出し元に伝播します。

これにより、現在のメソッド内で例外が処理されない場合、上位の呼び出し元に例外が渡され、最終的に適切なcatchブロックが見つかるまで伝播します。

もし上位でも例外がキャッチされなければ、プログラムは異常終了します。

再スローする際には、元の例外をラップして新しい例外をスローすることも可能です。

この記事でわかること

catchブロック内での例外処理の重要性
再スローと新規スローの使い分け
例外チェーンによるエラーログの詳細化
カスタム例外クラスの活用方法
リソース管理における例外処理の役割

目次から探す

catchブロック内で例外をスローするとは？

Javaにおける例外処理は、プログラムの安定性を保つために非常に重要です。

特に、try-catch構文を使用することで、発生した例外を捕捉し、適切に処理することができます。

ここでは、catchブロック内で例外をスローすることについて詳しく解説します。

catchブロックの基本的な動作

tryブロック内で発生した例外は、catchブロックで捕捉されます。

catchブロックは、特定の例外型に対して処理を行うためのもので、例外が発生した場合に実行されるコードを記述します。

例外が発生すると、tryブロックの実行が中断され、対応するcatchブロックが実行される。
catchブロック内では、例外オブジェクトを使ってエラーメッセージを表示したり、ログを記録したりすることができる。

catch内で例外を再スローするケース

catchブロック内で捕捉した例外を再スローすることができます。

これは、例外を上位の呼び出し元に伝えるために有効です。

再スローは、元の例外情報を保持したまま、別のメソッドやクラスに例外を伝播させることができます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            System.out.println("ファイル読み込み中にエラーが発生しました。");
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外を再スロー
            throw e;
        }
    }
}

ファイル読み込み中にエラーが発生しました。
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

新しい例外をスローするケース

catchブロック内で新しい例外をスローすることも可能です。

これは、特定のエラー状況に対して、より具体的な例外を作成してスローする場合に有効です。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            System.out.println("カスタム例外が発生しました: " + e.getMessage());
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

カスタム例外が発生しました: ファイルが見つかりません: test.txt

例外の伝播とは？

例外の伝播とは、発生した例外が呼び出し元のメソッドに伝わることを指します。

try-catch構文を使用することで、例外を捕捉し、適切に処理することができますが、再スローや新しい例外をスローすることで、例外をさらに上位のメソッドに伝えることが可能です。

例外が発生したメソッドで処理しきれない場合、上位のメソッドに例外を伝播させることができる。
これにより、アプリケーション全体で一貫したエラーハンドリングが可能になる。

catch内で例外をスローする際の注意点

catchブロック内で例外をスローする際には、いくつかの注意点があります。

これらを理解しておくことで、より効果的なエラーハンドリングが可能になります。

例外の再スローと新規スローの違い

例外の再スローと新規スローは、異なる目的で使用されます。

スクロールできます

特徴	再スロー	新規スロー
目的	元の例外をそのまま伝える	新しい例外を作成して伝える
例外情報の保持	元の例外情報を保持	新しい例外に情報を追加可能
使用例	エラーハンドリングを上位に委譲	特定のエラー状況を示す

再スローは、元の例外をそのまま上位に伝える場合に使用し、新規スローは新たなエラー状況を示すために使用します。

例外のラップ(例外チェーン)

例外のラップとは、ある例外を別の例外で包み込むことを指します。

これにより、元の例外情報を保持しつつ、より具体的なエラー情報を提供することができます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            System.out.println("カスタム例外が発生しました: " + e.getMessage());
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外をラップして新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName, e);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

カスタム例外が発生しました: ファイルが見つかりません: test.txt
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

スタックトレースの保持

例外を再スローまたは新規スローする際には、スタックトレースを保持することが重要です。

スタックトレースは、例外が発生した場所や原因を特定するための情報を提供します。

元の例外のスタックトレースを保持することで、デバッグが容易になります。

再スローの場合、元の例外のスタックトレースがそのまま保持される。
新規スローの場合、元の例外を原因として指定することで、スタックトレースを保持できる。

例外の適切なログ出力

例外が発生した際には、適切なログ出力を行うことが重要です。

ログには、例外の種類、メッセージ、スタックトレースなどの情報を含めることで、問題の診断が容易になります。

ログ出力には、ログレベル(INFO、WARN、ERRORなど)を設定する。
例外の詳細情報を含めることで、後からの分析がしやすくなる。

import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
    private static final Logger logger = Logger.getLogger(App.class.getName());
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            logger.log(Level.SEVERE, "カスタム例外が発生しました", e);
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName, e);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

SEVERE: カスタム例外が発生しました
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

適切なログ出力を行うことで、問題の特定や解決が迅速に行えるようになります。

例外の再スローと新規スローの使い分け

例外処理において、再スローと新規スローはそれぞれ異なる目的を持っています。

適切に使い分けることで、エラーハンドリングの効果を最大化できます。

再スローが有効なケース

再スローは、元の例外をそのまま上位に伝える場合に有効です。

以下のようなケースで再スローを使用することが推奨されます。

エラーハンドリングを上位に委譲したい場合: 例外を捕捉したメソッドで処理しきれない場合、上位のメソッドに処理を委譲するために再スローします。
元の例外情報を保持したい場合: 例外の詳細情報を失わずに、呼び出し元に伝えたいときに再スローが適しています。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            System.out.println("ファイル読み込み中にエラーが発生しました。");
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外を再スロー
            throw e;
        }
    }
}

新規スローが有効なケース

新規スローは、特定のエラー状況を示すために新しい例外を作成してスローする場合に有効です。

以下のようなケースで新規スローを使用することが推奨されます。

特定のエラー状況を示したい場合: 例えば、ファイルが見つからない場合にカスタム例外をスローすることで、エラーの内容を明確に伝えることができます。
エラーの種類を明確にしたい場合: 新しい例外を作成することで、エラーの種類を明確にし、適切なエラーハンドリングを行うことができます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            System.out.println("カスタム例外が発生しました: " + e.getMessage());
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

例外の情報を保持する重要性

例外を再スローまたは新規スローする際には、例外の情報を保持することが重要です。

元の例外のスタックトレースやメッセージを保持することで、問題の診断が容易になります。

デバッグの容易さ: 例外の情報を保持することで、どの部分でエラーが発生したのかを特定しやすくなります。
エラーの原因分析: 例外の詳細情報を保持することで、エラーの原因を分析し、適切な対策を講じることができます。

例外のカプセル化と抽象化

例外のカプセル化と抽象化は、エラーハンドリングをより効果的に行うための手法です。

カプセル化: 例外をカスタムクラスでラップすることで、エラー情報を一元管理できます。

これにより、エラーの種類や内容を明確にし、エラーハンドリングを簡素化します。

抽象化: 例外の抽象クラスを作成することで、異なるエラー状況を統一的に扱うことができます。

これにより、エラーハンドリングのコードがシンプルになり、保守性が向上します。

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}
class FileNotFoundException extends CustomException {
    public FileNotFoundException(String fileName) {
        super("ファイルが見つかりません: " + fileName);
    }
}

このように、例外のカプセル化と抽象化を行うことで、エラーハンドリングの柔軟性と可読性が向上します。

実際のコード例

ここでは、例外の再スロー、新規スロー、例外チェーン、スタックトレースの確認方法について具体的なコード例を示します。

再スローのコード例

再スローの例では、IOExceptionを捕捉し、そのまま上位に伝える方法を示します。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            System.out.println("ファイル読み込み中にエラーが発生しました。");
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外を再スロー
            throw e;
        }
    }
}

ファイル読み込み中にエラーが発生しました。
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

新規スローのコード例

新規スローの例では、IOExceptionを捕捉し、カスタム例外をスローする方法を示します。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            System.out.println("カスタム例外が発生しました: " + e.getMessage());
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

カスタム例外が発生しました: ファイルが見つかりません: test.txt

例外チェーンのコード例

例外チェーンの例では、元の例外を保持しつつ、新しいカスタム例外をスローします。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            System.out.println("カスタム例外が発生しました: " + e.getMessage());
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外をラップして新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName, e);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

カスタム例外が発生しました: ファイルが見つかりません: test.txt
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

スタックトレースの確認方法

スタックトレースは、例外が発生した際にprintStackTrace()メソッドを呼び出すことで確認できます。

これにより、例外が発生した場所や原因を特定するための情報が得られます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            // スタックトレースを表示
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        FileReader fileReader = new FileReader(fileName);
        // ファイルの読み込み処理
    }
}

java.io.FileNotFoundException: test.txt (そのようなファイルはありません)
	at java.base/java.io.FileReader.<init>(FileReader.java:59)
	at App.readFile(App.java:8)
	at App.main(App.java:4)

このように、スタックトレースを確認することで、どのメソッドで例外が発生したのか、どのような経路で呼び出されたのかを把握することができます。

これにより、デバッグが容易になります。

応用例

ここでは、Javaにおける例外処理の応用例をいくつか紹介します。

具体的には、カスタム例外クラスを使用した再スロー、例外の再スローを使ったリソース管理、例外チェーンを使ったエラーログの詳細化について解説します。

カスタム例外クラスを使用した再スロー

カスタム例外クラスを作成し、特定のエラー状況に対して再スローする方法を示します。

これにより、エラーの内容をより明確に伝えることができます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (FileReadException e) {
            System.out.println("ファイル読み込み中にエラーが発生しました: " + e.getMessage());
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws FileReadException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // カスタム例外を再スロー
            throw new FileReadException("ファイルが見つかりません: " + fileName, e);
        }
    }
}
class FileReadException extends Exception {
    public FileReadException(String message, Throwable cause) {
        super(message, cause);
    }
}

ファイル読み込み中にエラーが発生しました: ファイルが見つかりません: test.txt
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

例外の再スローを使ったリソース管理

例外の再スローを利用して、リソース管理を行う方法を示します。

特に、ファイルやデータベース接続などのリソースを扱う際に、例外を適切に処理することが重要です。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            System.out.println("リソース管理中にエラーが発生しました。");
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外を再スロー
            throw e;
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    // クローズ時の例外を再スロー
                    throw new IOException("ファイルクローズ中にエラーが発生しました", e);
                }
            }
        }
    }
}

リソース管理中にエラーが発生しました。
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)

例外チェーンを使ったエラーログの詳細化

例外チェーンを使用して、エラーログに詳細な情報を記録する方法を示します。

これにより、エラーの原因を特定しやすくなります。

import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
    private static final Logger logger = Logger.getLogger(App.class.getName());
    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (CustomException e) {
            logger.log(Level.SEVERE, "エラーが発生しました", e);
        }
    }
    public static void readFile(String fileName) throws CustomException {
        try {
            FileReader fileReader = new FileReader(fileName);
            // ファイルの読み込み処理
        } catch (IOException e) {
            // 例外をラップして新しい例外をスロー
            throw new CustomException("ファイルが見つかりません: " + fileName, e);
        }
    }
}
class CustomException extends Exception {
    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

SEVERE: エラーが発生しました
java.io.FileNotFoundException: test.txt (そのようなファイルはありません)
	at java.base/java.io.FileReader.<init>(FileReader.java:59)
	at App.readFile(App.java:8)
	at App.main(App.java:4)

このように、例外チェーンを使用することで、エラーログに詳細な情報を記録し、問題の診断を容易にすることができます。

よくある質問

catch内で例外をスローするとパフォーマンスに影響はある？

catch内で例外をスローすること自体がパフォーマンスに直接的な影響を与えるわけではありませんが、例外処理は通常のフローよりもコストがかかるため、頻繁に例外が発生する状況ではパフォーマンスに影響を及ぼす可能性があります。

特に、例外が発生するたびにスタックトレースが生成されるため、これがパフォーマンスの低下を引き起こすことがあります。

したがって、例外は通常の制御フローとして使用するべきではなく、予期しないエラーに対する対処として利用することが推奨されます。

catch内で例外をスローしない方が良い場合は？

catch内で例外をスローしない方が良い場合は以下のようなケースです。

エラーを適切に処理できる場合: 例外をスローするのではなく、エラーメッセージを表示したり、リトライ処理を行ったりすることで、問題を解決できる場合。
リソースのクリーンアップが必要な場合: 例外をスローすると、リソースのクリーンアップが適切に行われない可能性があるため、必要に応じてリソースを解放する処理を行うことが重要です。
アプリケーションの状態を維持する必要がある場合: 例外をスローすることでアプリケーションの状態が不安定になる可能性がある場合、適切なエラーハンドリングを行うことが望ましいです。