MENU
  1. ホーム
  2. Java
  3. 言語仕様
  4. 例外処理
  5. [Java] try-catch-finally構文の使い方 – 例外処理

[Java] try-catch-finally構文の使い方 – 例外処理

Javaのtry-catch-finally構文は、例外処理を行うための基本的な仕組みです。

tryブロック内に例外が発生する可能性のあるコードを記述し、catchブロックでその例外をキャッチして処理します。

finallyブロックは、例外の有無にかかわらず必ず実行されるコードを記述する場所です。

例えば、リソースの解放や後処理を行う際に使用されます。

finallyは省略可能ですが、tryとcatchはセットで使用されます。

この記事でわかること
  • 例外処理の基本構文を理解
  • try-catch-finallyの使い方
  • カスタム例外の作成方法
  • 例外処理のベストプラクティス
  • 応用例を通じた実践的な知識

目次から探す

例外処理とは

例外処理は、プログラムの実行中に発生する予期しないエラーや異常な状況を管理するためのメカニズムです。

Javaでは、例外が発生すると通常のプログラムの流れが中断されますが、例外処理を用いることで、プログラムが異常終了することを防ぎ、エラーに対処することができます。

これにより、ユーザーに対して適切なエラーメッセージを表示したり、必要なリソースを解放したりすることが可能になります。

例外処理を適切に行うことで、プログラムの信頼性や安定性を向上させることができます。

try-catch-finally構文の基本

Javaにおける例外処理の基本構文であるtry-catch-finallyは、エラーが発生する可能性のあるコードを安全に実行するための方法です。

この構文を使用することで、プログラムの安定性を保ちながら、エラーに対処することができます。

tryブロックの役割

tryブロックは、例外が発生する可能性のあるコードを囲む部分です。

このブロック内でエラーが発生した場合、Javaはそのエラーをキャッチし、次に指定されたcatchブロックに制御を移します。

tryブロック内のコードが正常に実行された場合、catchブロックはスキップされます。

catchブロックの役割

catchブロックは、tryブロック内で発生した例外を処理するための部分です。

catchブロックは、特定の例外クラスを指定することで、その例外が発生した際に実行されるコードを定義します。

複数のcatchブロックを用意することで、異なる種類の例外に対して異なる処理を行うことができます。

finallyブロックの役割

finallyブロックは、try-catch構文の最後に配置される部分で、例外の発生に関わらず必ず実行されるコードを記述します。

リソースの解放や後処理など、プログラムの終了時に必ず行いたい処理をここに記述します。

たとえtryブロック内で例外が発生しても、finallyブロックは実行されます。

try-catch-finallyの基本的な流れ

  1. tryブロック内のコードが実行される。
  2. 例外が発生した場合、tryブロックの実行が中断され、対応するcatchブロックが実行される。
  3. catchブロックが実行された後、またはtryブロックが正常に終了した後、finallyブロックが実行される。
  4. プログラムは次の処理に進む。

この流れにより、例外が発生してもプログラムが適切に処理を続けられるようになります。

catchブロックの詳細

catchブロックは、tryブロック内で発生した例外を処理するための重要な部分です。

ここでは、catchブロックの詳細について解説します。

複数の例外をキャッチする方法

複数の例外をキャッチするためには、複数のcatchブロックを用意することができます。

各catchブロックは異なる例外クラスを指定し、それぞれの例外に対して異なる処理を行うことができます。

以下はその例です。

import java.io.FileNotFoundException;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            // 例外が発生する可能性のあるコード
            throw new FileNotFoundException("ファイルが見つかりません");
        } catch (FileNotFoundException e) {
            // FileNotFoundExceptionの処理
            System.out.println("ファイルが見つかりません: " + e.getMessage());
        } catch (IOException e) {
            // IOExceptionの処理
            System.out.println("入出力エラー: " + e.getMessage());
        }
    }
}
ファイルが見つかりません: ファイルが見つかりません

例外クラスの階層とキャッチの順序

Javaの例外クラスは階層構造を持っており、親クラスの例外をキャッチすると、その子クラスの例外もキャッチされます。

したがって、catchブロックは特定の例外から一般的な例外の順に記述する必要があります。

具体的には、より具体的な例外を先に、一般的な例外を後に記述します。

マルチキャッチ構文の使い方

Java 7以降、マルチキャッチ構文を使用することで、複数の例外を1つのcatchブロックで処理することができます。

これにより、冗長なコードを避けることができます。

以下はその例です。

import java.io.FileNotFoundException;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            // 例外が発生する可能性のあるコード
            throw new IOException("入出力エラーが発生しました");
        } catch (FileNotFoundException | IOException e) {
            // FileNotFoundExceptionまたはIOExceptionの処理
            System.out.println("エラー: " + e.getMessage());
        }
    }
}
エラー: 入出力エラーが発生しました

例外オブジェクトの取得と利用

catchブロック内では、例外オブジェクトを利用してエラーの詳細情報を取得することができます。

例外オブジェクトには、エラーメッセージやスタックトレースなどの情報が含まれています。

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

例として、getMessage()メソッドを使用してエラーメッセージを取得することができます。

finallyブロックの詳細

finallyブロックは、try-catch構文の一部として、例外処理の後に必ず実行されるコードを記述するための部分です。

ここでは、finallyブロックの詳細について解説します。

finallyブロックの実行タイミング

finallyブロックは、tryブロック内のコードが正常に実行された場合でも、例外が発生した場合でも、必ず実行されます。

具体的には、tryブロックが正常に終了した後、またはcatchブロックが実行された後に、必ず実行されるため、リソースの解放や後処理に適しています。

finallyブロックの主な用途

finallyブロックの主な用途は、リソースの解放や後処理を行うことです。

たとえば、ファイルやデータベース接続などのリソースを使用した後に、それらを確実に閉じるためにfinallyブロックを使用します。

これにより、リソースリークを防ぎ、プログラムの安定性を向上させることができます。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("example.txt");
            // ファイルの読み込み処理
        } catch (IOException e) {
            System.out.println("エラー: " + e.getMessage());
        } finally {
            // リソースの解放
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    System.out.println("リソースの解放中にエラー: " + e.getMessage());
                }
            }
        }
    }
}
エラー: example.txt (そのようなファイルはありません)

finallyブロックが実行されないケース

finallyブロックは通常、try-catch構文の後に必ず実行されますが、以下のような特定のケースでは実行されないことがあります。

  • JVMが強制終了した場合
  • スレッドが強制終了された場合
  • 無限ループに入った場合

これらのケースでは、finallyブロックが実行されないため、リソースの解放が行われない可能性があります。

try-with-resourcesとの違い

try-with-resourcesは、Java 7以降に導入された構文で、リソースを自動的に管理するためのものです。

この構文を使用すると、tryブロック内で使用したリソースは、tryブロックの終了時に自動的に閉じられます。

これにより、finallyブロックを使用して手動でリソースを解放する必要がなくなります。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try (FileReader fileReader = new FileReader("example.txt")) {
            // ファイルの読み込み処理
        } catch (IOException e) {
            System.out.println("エラー: " + e.getMessage());
        }
    }
}
エラー: example.txt (そのようなファイルはありません)

このように、try-with-resourcesを使用することで、リソース管理が簡素化され、コードがよりクリーンになります。

例外の再スロー

例外の再スローは、catchブロック内で捕捉した例外を再度スローすることを指します。

これにより、上位の呼び出し元に例外を伝播させることができます。

ここでは、例外の再スローについて詳しく解説します。

例外を再スローする方法

例外を再スローするには、catchブロック内でthrowキーワードを使用します。

再スローする際には、捕捉した例外オブジェクトをそのままスローすることが一般的です。

以下はその例です。

import java.io.FileNotFoundException;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("example.txt");
        } catch (IOException e) {
            System.out.println("エラーが発生しました: " + e.getMessage());
        }
    }
    public static void readFile(String fileName) throws IOException {
        try {
            // ファイルを読み込む処理
            throw new FileNotFoundException("ファイルが見つかりません: " + fileName);
        } catch (FileNotFoundException e) {
            // 例外を再スロー
            throw e;
        }
    }
}
エラーが発生しました: ファイルが見つかりません: example.txt

再スローの用途と注意点

再スローの主な用途は、例外を上位の呼び出し元に伝えることです。

これにより、呼び出し元で適切なエラーハンドリングを行うことができます。

ただし、再スローする際には以下の点に注意が必要です。

  • 例外の種類: 再スローする例外は、呼び出し元で処理可能なものである必要があります。

適切な例外クラスを選択することが重要です。

  • スタックトレースの保持: 再スローする際に、元の例外のスタックトレースを保持することが重要です。

これにより、エラーの発生場所を特定しやすくなります。

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

スタックトレースは、例外が発生した際のメソッド呼び出しの履歴を示します。

スタックトレースを確認することで、エラーの発生場所や原因を特定することができます。

スタックトレースは、例外オブジェクトのprintStackTrace()メソッドを呼び出すことで表示できます。

以下はその例です。

import java.io.FileNotFoundException;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            readFile("example.txt");
        } catch (IOException e) {
            // スタックトレースを表示
            e.printStackTrace();
        }
    }
    public static void readFile(String fileName) throws IOException {
        try {
            // ファイルを読み込む処理
            throw new FileNotFoundException("ファイルが見つかりません: " + fileName);
        } catch (FileNotFoundException e) {
            // 例外を再スロー
            throw e;
        }
    }
}
java.io.FileNotFoundException: ファイルが見つかりません: example.txt
	at App.readFile(App.java:10)
	at App.main(App.java:5)

このように、printStackTrace()メソッドを使用することで、例外の詳細な情報を得ることができ、デバッグに役立ちます。

カスタム例外の作成

カスタム例外は、特定のアプリケーションやビジネスロジックに特化した例外を定義するためのクラスです。

これにより、より明確で意味のあるエラーメッセージを提供し、エラーハンドリングを容易にします。

ここでは、カスタム例外の作成方法とその利点について解説します。

カスタム例外クラスの作成方法

カスタム例外クラスは、JavaのExceptionクラスを継承して作成します。

必要に応じて、コンストラクタをオーバーロードしてエラーメッセージや原因を指定できるようにします。

以下はカスタム例外クラスの例です。

// カスタム例外クラスの定義
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message); // 親クラスのコンストラクタを呼び出す
    }
    public CustomException(String message, Throwable cause) {
        super(message, cause); // 親クラスのコンストラクタを呼び出す
    }
}

カスタム例外を使うメリット

カスタム例外を使用することには以下のようなメリットがあります。

スクロールできます
メリット説明
明確なエラーメッセージ特定のエラーに対して意味のあるメッセージを提供できる。
エラーハンドリングの柔軟性特定のエラーに対して異なる処理を行うことができる。
コードの可読性向上エラーの種類が明示的になるため、コードが理解しやすくなる。

カスタム例外の使用例

カスタム例外を使用する例として、特定の条件でエラーをスローするメソッドを考えてみましょう。

以下は、カスタム例外を使用したサンプルコードです。

public class App {
    public static void main(String[] args) {
        try {
            validateAge(15); // 年齢が不正な場合
        } catch (CustomException e) {
            System.out.println("エラー: " + e.getMessage());
        }
    }
    public static void validateAge(int age) throws CustomException {
        if (age < 18) {
            // カスタム例外をスロー
            throw new CustomException("年齢は18歳以上でなければなりません。");
        }
        System.out.println("年齢は有効です。");
    }
}
エラー: 年齢は18歳以上でなければなりません。

この例では、validateAgeメソッドが年齢を検証し、条件を満たさない場合にカスタム例外CustomExceptionをスローします。

これにより、エラーメッセージが明確になり、エラーハンドリングが容易になります。

例外処理のベストプラクティス

例外処理は、プログラムの信頼性と安定性を向上させるために重要です。

以下では、例外処理に関するベストプラクティスを紹介します。

例外処理の設計指針

例外処理を設計する際には、以下の指針を考慮することが重要です。

スクロールできます
指針説明
明確な例外の使用具体的な例外クラスを使用し、エラーの種類を明示する。
適切なスコープでの処理例外を適切なレベルで処理し、必要に応じて再スローする。
一貫性のあるエラーハンドリングすべての例外に対して一貫した方法で処理を行う。

例外を無視しない

例外を無視することは、プログラムのバグや不具合を引き起こす原因となります。

catchブロックで例外を捕捉した場合は、必ず何らかの処理を行うべきです。

例えば、エラーログを記録したり、ユーザーにエラーメッセージを表示したりすることが重要です。

無視する場合は、少なくともログに記録することをお勧めします。

try {
    // 例外が発生する可能性のあるコード
} catch (IOException e) {
    // 例外を無視せず、ログに記録
    System.err.println("エラーが発生しました: " + e.getMessage());
}

例外メッセージの適切な記述

例外メッセージは、エラーの原因を特定するための重要な情報です。

以下のポイントに注意して、適切なメッセージを記述しましょう。

  • 具体性: エラーの内容を具体的に記述する。
  • ユーザーフレンドリー: ユーザーが理解できる言葉で記述する。
  • 必要な情報の提供: エラーの発生場所や原因を示す情報を含める。 
throw new CustomException("ファイルが見つかりません: " + fileName);

リソースの確実な解放

リソース(ファイル、データベース接続など)は、使用後に必ず解放する必要があります。

try-catch-finally構文を使用して、例外が発生してもリソースが確実に解放されるようにします。

また、Java 7以降はtry-with-resources構文を使用することで、リソースの自動管理が可能です。

try (FileReader fileReader = new FileReader("example.txt")) {
    // ファイルの読み込み処理
} catch (IOException e) {
    System.out.println("エラー: " + e.getMessage());
}
// fileReaderは自動的に閉じられる

このように、リソースの解放を確実に行うことで、リソースリークを防ぎ、プログラムの安定性を向上させることができます。

応用例

例外処理は、さまざまなシナリオで応用可能です。

ここでは、いくつかの応用例を紹介します。

ネストしたtry-catch-finallyの使い方

ネストしたtry-catch-finally構文を使用することで、複数の異なる処理を行いながら、各処理に対する例外を個別に管理することができます。

以下はその例です。

import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            try (FileReader fileReader = new FileReader("example.txt")) {
                // ファイルの読み込み処理
                int data = fileReader.read();
                System.out.println("データ: " + data);
            } catch (IOException e) {
                System.out.println("ファイルの読み込み中にエラー: " + e.getMessage());
            }
        } catch (Exception e) {
            System.out.println("予期しないエラー: " + e.getMessage());
        }
    }
}
ファイルの読み込み中にエラー: example.txt (そのようなファイルはありません)

例外処理を使ったリソース管理

例外処理を使用して、リソースを安全に管理することができます。

try-with-resources構文を使用することで、リソースの自動解放が可能です。

以下はその例です。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("エラー: " + e.getMessage());
        }
    }
}
エラー: example.txt (そのようなファイルはありません)

例外処理を使った入力検証

例外処理を使用して、ユーザーからの入力を検証することができます。

たとえば、数値の入力を受け付ける際に、数値以外の入力があった場合に例外をスローすることができます。

import java.util.Scanner;
public class App {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("年齢を入力してください: ");
        try {
            int age = Integer.parseInt(scanner.nextLine());
            System.out.println("年齢: " + age);
        } catch (NumberFormatException e) {
            System.out.println("無効な入力: 数値を入力してください。");
        } finally {
            scanner.close();
        }
    }
}
無効な入力: 数値を入力してください。

例外処理を使ったログ出力

例外処理を使用して、エラーが発生した際にログを出力することができます。

これにより、後でエラーの原因を追跡しやすくなります。

以下はその例です。

import java.io.FileWriter;
import java.io.IOException;
public class App {
    public static void main(String[] args) {
        try {
            // エラーを発生させる
            throw new IOException("ファイルが見つかりません");
        } catch (IOException e) {
            logError(e);
        }
    }
    public static void logError(Exception e) {
        try (FileWriter writer = new FileWriter("error.log", true)) {
            writer.write("エラー: " + e.getMessage() + "\n");
        } catch (IOException logException) {
            System.out.println("ログ出力中にエラー: " + logException.getMessage());
        }
    }
}
ログ出力中にエラー: error.log (そのようなファイルはありません)

このように、例外処理を活用することで、さまざまなシナリオでのエラーハンドリングやリソース管理が可能になります。

よくある質問

finallyブロックは必ず実行されるのか？

基本的に、finallyブロックはtryブロック内で例外が発生した場合でも、正常に終了した場合でも必ず実行されます。

ただし、以下の特定のケースではfinallyブロックが実行されないことがあります。

  • JVMが強制終了した場合
  • スレッドが強制終了された場合
  • 無限ループに入った場合
  • System.exit()メソッドが呼び出された場合

これらのケースでは、finallyブロックが実行されないため、リソースの解放が行われない可能性があります。

例外処理を使わないとどうなる？

例外処理を使用しない場合、プログラム内で発生した例外は未処理のままとなり、通常はプログラムが異常終了します。

これにより、ユーザーに対してエラーメッセージが表示されることなく、データの損失やリソースのリークが発生する可能性があります。

また、デバッグが難しくなり、エラーの原因を特定するのが困難になります。

例外処理のパフォーマンスへの影響は？

例外処理は、通常のプログラムの流れに比べてオーバーヘッドが発生します。

特に、例外が頻繁に発生する場合、パフォーマンスに悪影響を及ぼすことがあります。

ただし、例外処理はエラーハンドリングのための重要な手段であり、適切に使用することでプログラムの信頼性を向上させることができます。

したがって、例外処理を使用する際は、エラーが発生する可能性のある部分にのみ適用し、通常の処理の流れを維持することが推奨されます。

まとめ

この記事では、Javaにおける例外処理の基本から応用までを詳しく解説しました。

特に、try-catch-finally構文の使い方やカスタム例外の作成、例外処理のベストプラクティスについて触れ、実際のコード例を通じて具体的な理解を深めました。

これを機に、例外処理を適切に活用し、より堅牢で信頼性の高いプログラムを作成することを目指してみてください。

目次に戻る

当サイトはリンクフリーです。出典元を明記していただければ、ご自由に引用していただいて構いません。

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

例外処理
  • URLをコピーしました！

関連記事

目次から探す