MENU
  1. ホーム
  2. Java
  3. Javaのfinallyブロックで行うリソースクリーンアップの徹底ガイド

Javaのfinallyブロックで行うリソースクリーンアップの徹底ガイド

Java

Javaプログラミングにおいて、リソースの適切な管理は非常に重要です。ファイルやネットワーク接続、データベース接続などのリソースは、使用後に確実に解放されなければ、メモリリークやシステムのパフォーマンス低下につながります。Javaでは、リソースのクリーンアップを確実に行うためにfinallyブロックがよく使用されます。本記事では、finallyブロックの基本的な使い方から、その重要性、さらに実際のコード例やベストプラクティスまで、リソース管理に関する知識を深めるための内容を詳しく解説します。

目次

リソース管理の重要性

ソフトウェア開発において、リソース管理はアプリケーションの安定性と効率性を保つために欠かせない要素です。リソースとは、ファイルハンドル、ネットワークソケット、データベース接続など、システムの外部リソースにアクセスする際に利用するものを指します。これらのリソースは有限であり、適切に解放されない場合、メモリリークやシステムリソースの枯渇を引き起こす可能性があります。

Javaでは、リソース管理を怠ると、ガベージコレクタが介入するまでリソースが解放されず、アプリケーションのパフォーマンスが低下するリスクがあります。さらに、ネットワーク接続やファイルシステムなどでは、リソースが開放されないことで他のプロセスやユーザーに影響を及ぼす可能性もあります。そのため、リソースの確実な解放は、プログラムの信頼性を高めるためにも極めて重要です。

finallyブロックの基本概念

finallyブロックは、Javaの例外処理において特別な役割を持つコードブロックです。tryブロックで発生した例外の有無にかかわらず、必ず実行されることが保証されています。これにより、tryブロックで使用したリソースを確実に解放するためのコードを記述する場所として非常に有用です。

例えば、ファイルやデータベース接続などのリソースは、使用後に必ず閉じる必要がありますが、tryブロック内で例外が発生した場合、通常の処理フローではこれらのクリーンアップ処理が行われないことがあります。finallyブロックを使用することで、例外が発生しても、必ずリソースのクリーンアップが実行されるようになります。

以下は、finallyブロックの基本的な使用例です：

FileInputStream fis = null;
try {
    fis = new FileInputStream("example.txt");
    // ファイルを読み込む処理
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

この例では、tryブロック内でファイルを開き、finallyブロックでそのファイルを確実に閉じています。finallyブロックがあることで、ファイルが適切にクローズされ、システムリソースが無駄なく管理されることが保証されます。

finallyブロックを使うべき場面

finallyブロックは、主にリソースのクリーンアップや特定の処理を確実に実行する必要がある場合に使用されます。具体的に、どのような場面でfinallyブロックを使用すべきかを見ていきましょう。

リソースの解放が必要なとき

ファイルハンドル、データベース接続、ネットワークソケットなど、外部リソースを扱う場合には、リソースを解放するコードをfinallyブロックに配置します。これにより、例外が発生したとしてもリソースが確実に解放されるため、メモリリークやリソースの枯渇を防ぐことができます。

特定の操作を確実に行いたいとき

トランザクションのロールバックやログの書き込みなど、特定の操作を必ず実行したい場合にもfinallyブロックが有効です。たとえtryブロック内で予期しない例外が発生しても、finallyブロック内の処理が保証されるため、システムの状態を正しく保つことができます。

複数の例外が発生する可能性があるとき

tryブロックで複数の例外が発生する可能性があり、どの例外が発生しても共通のクリーンアップ処理が必要な場合、finallyブロックを使うことで、例外の種類にかかわらず一定の処理を実行できます。

これらの場面において、finallyブロックを適切に活用することで、リソース管理を確実に行い、プログラムの安定性を向上させることができます。

try-catch-finallyの基本構造

Javaの例外処理は、try-catch-finallyという構造を使用して行われます。この構造により、例外の発生をキャッチし、その後のクリーンアップ処理を確実に行うことができます。それぞれの部分がどのような役割を持ち、どのように機能するのかを詳しく見ていきましょう。

tryブロック

tryブロックは、例外が発生する可能性のあるコードを囲むために使用されます。このブロック内に書かれたコードは、実行中に例外が発生した場合、即座にcatchブロックに処理が移ります。例外が発生しなかった場合は、tryブロック内のすべてのコードが正常に実行されます。

try {
    // 例外が発生する可能性のあるコード
}

catchブロック

catchブロックは、tryブロック内で発生した特定の例外をキャッチして処理するために使用されます。catchブロックでは、例外の種類に応じた適切なエラーハンドリングを行います。複数の例外タイプに対応するために、複数のcatchブロックを使用することもできます。

catch (ExceptionType e) {
    // 例外に対する処理
}

finallyブロック

finallyブロックは、例外の有無にかかわらず、tryブロックの終了後に必ず実行されるコードを記述する場所です。リソースの解放やクリーンアップ処理など、プログラムの安定性を確保するために必要な処理をここに記述します。

finally {
    // 常に実行されるコード
}

基本的なtry-catch-finallyの例

以下に、try-catch-finally構造の基本的な使用例を示します。

FileInputStream fis = null;
try {
    fis = new FileInputStream("example.txt");
    // ファイルの読み取り処理
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

この例では、tryブロックでファイルを読み取り、例外が発生した場合にはcatchブロックで処理し、最終的にfinallyブロックでファイルをクローズしています。このように、try-catch-finally構造を使用することで、リソース管理とエラーハンドリングを統一的に行うことができます。

リソースクリーンアップのベストプラクティス

リソースクリーンアップは、プログラムの安定性と効率性を保つために不可欠な要素です。ここでは、Javaでリソースを適切にクリーンアップするためのベストプラクティスを紹介します。

1. リソースは早めに解放する

リソースは必要以上に長く保持せず、使用が終わったらすぐに解放することが重要です。例えば、ファイルハンドルやデータベース接続は、他のプロセスやスレッドが使用するためのリソースを消費します。finallyブロックを使用して、例外が発生しても確実にリソースを解放するようにしましょう。

2. 例外発生時のクリーンアップを保証する

例外が発生した場合でも、リソースが確実に解放されるようにすることが必要です。try-catch-finally構造を使用し、finallyブロックでリソースの解放を行うことで、例外処理が行われた場合でもリソースが漏れずに解放されることを保証できます。

3. Nullチェックを忘れない

リソースを解放する際には、必ずそのリソースがnullでないことを確認してから解放処理を行うようにします。例えば、ファイルが開けなかった場合でも、finallyブロックでクローズ処理が行われるため、nullチェックを怠るとNullPointerExceptionが発生する可能性があります。

4. 外部ライブラリを使用する場合はその仕様を理解する

Javaでは、サードパーティのライブラリを使用することも多くあります。これらのライブラリがどのようにリソース管理を行っているかを理解し、そのライブラリが提供する適切なクリーンアップメソッドを使用することが重要です。

5. try-with-resources構文を活用する

Java 7以降では、try-with-resources構文を使用することで、リソースの自動解放が可能です。この構文を活用することで、手動でクローズする必要がなくなり、コードのシンプルさと安全性が向上します。

try (FileInputStream fis = new FileInputStream("example.txt")) {
    // ファイルの読み取り処理
} catch (IOException e) {
    e.printStackTrace();
}

この例では、try-with-resourcesを使用することで、finallyブロックでクローズ処理を書く必要がなくなります。

6. 複数のリソースを管理する際の工夫

複数のリソースを扱う場合、それぞれのリソースを確実にクリーンアップするように順序に気を付けましょう。一般的には、最後に開いたリソースを最初にクローズする「逆順」でクリーンアップを行うのが良いとされています。

これらのベストプラクティスを守ることで、Javaプログラムの信頼性と効率性を向上させることができ、リソースリークやパフォーマンスの問題を防ぐことができます。

自動リソース管理 (try-with-resources)

Java 7で導入されたtry-with-resources構文は、リソース管理を自動化し、コードの簡素化と信頼性の向上を実現します。この構文を使用することで、finallyブロックを明示的に書かなくても、リソースが自動的に解放されるようになります。

try-with-resourcesの基本構造

try-with-resources構文は、AutoCloseableインターフェースを実装しているリソースを使用する際に利用できます。この構文では、tryブロックの括弧内でリソースを宣言し、そのブロックが終了すると自動的にリソースが閉じられます。

try (FileInputStream fis = new FileInputStream("example.txt")) {
    // ファイルの読み取り処理
} catch (IOException e) {
    e.printStackTrace();
}

上記の例では、tryブロック内でFileInputStreamを開きますが、finallyブロックを明示的に記述することなく、tryブロックが終了すると自動的にfisが閉じられます。

複数のリソースを扱う場合の構文

try-with-resources構文は、複数のリソースを同時に管理することもできます。複数のリソースを使用する場合、それらをセミコロンで区切って宣言します。

try (
    FileInputStream fis = new FileInputStream("example.txt");
    BufferedReader reader = new BufferedReader(new InputStreamReader(fis))
) {
    // ファイルの読み取り処理
} catch (IOException e) {
    e.printStackTrace();
}

この例では、FileInputStreamとBufferedReaderの両方のリソースがtryブロックの終了時に自動的に閉じられます。

try-with-resourcesの利点

try-with-resources構文には、いくつかの利点があります。

  • コードの簡素化: finallyブロックを書かなくて済むため、コードが短く、読みやすくなります。
  • エラーハンドリングの一元化: リソースのクローズに失敗した場合でも、自動的にエラーハンドリングが行われるため、例外処理が統一されます。
  • リソースリークの防止: 明示的にリソースを閉じ忘れることがなくなり、リソースリークを防止できます。

AutoCloseableインターフェース

try-with-resources構文で使用するリソースは、AutoCloseableインターフェースを実装している必要があります。このインターフェースには、close()メソッドが定義されており、リソースが自動的に解放される際にこのメソッドが呼び出されます。AutoCloseableは、Closeableのスーパーインターフェースであり、InputStreamやOutputStreamなどのリソースがこのインターフェースを実装しています。

public interface AutoCloseable {
    void close() throws Exception;
}

このインターフェースにより、カスタムリソースもtry-with-resourcesで管理できるようにすることが可能です。

try-with-resources構文を活用することで、リソース管理がシンプルで安全になり、エラーの少ない信頼性の高いコードを書くことができます。Javaプログラムの効率的なリソース管理において、現代的なベストプラクティスとされています。

finallyブロックでのエラーハンドリング

finallyブロックは、リソースのクリーンアップを確実に実行するために非常に有用ですが、このブロック内でのエラーハンドリングにも注意が必要です。finallyブロックでのエラーハンドリングが不適切だと、例外が抑制されたり、予期しない動作が発生したりする可能性があります。

finallyブロックで例外を発生させない

finallyブロック内で例外が発生すると、tryまたはcatchブロックで発生した例外が上書きされてしまう可能性があります。これにより、元の例外情報が失われることがあります。例えば、以下のコードでは、finallyブロックで発生した例外がtryブロックで発生した例外を上書きしてしまいます。

try {
    // 例外が発生する可能性のあるコード
} catch (Exception e) {
    e.printStackTrace();
} finally {
    // 例外が発生
    throw new RuntimeException("Finally block exception");
}

この例では、finallyブロック内の例外によって、tryブロックやcatchブロックで発生した例外が無視される可能性があります。したがって、finallyブロック内では可能な限り例外を発生させないようにすることが推奨されます。

例外をキャッチしてログを残す

finallyブロックで発生する可能性のある例外を無視せず、適切にキャッチしてログを残すことが重要です。これにより、finallyブロック内で発生した問題をデバッグしやすくなります。

finally {
    try {
        // リソースのクリーンアップ処理
    } catch (Exception e) {
        // 例外をキャッチしてログを残す
        System.err.println("Exception in finally block: " + e.getMessage());
    }
}

この例では、finallyブロック内で例外が発生した場合、その例外をキャッチしてエラーメッセージをログに出力しています。これにより、リソース解放時の問題を把握することができます。

finallyブロックでのリソースクリーンアップに集中する

finallyブロックは、リソースのクリーンアップに専念させるべきです。エラーハンドリングやビジネスロジックの処理をfinallyブロック内に書くと、コードが複雑になり、予期しない挙動を引き起こす可能性があります。finallyブロックはあくまでリソース解放のために使用し、必要に応じてエラーをログに残す程度に留めましょう。

複数の例外を抑制しないよう注意する

Java 7以降では、try-with-resources構文を使用すると、複数の例外が発生した場合でも元の例外が抑制されず、すべての例外情報を参照することが可能です。しかし、finallyブロックで複数のリソースをクローズする場合、それぞれの例外を適切に処理する必要があります。

finally {
    Exception suppressed = null;
    try {
        // 最初のリソースのクリーンアップ
    } catch (Exception e) {
        suppressed = e;
    }
    try {
        // 次のリソースのクリーンアップ
    } catch (Exception e) {
        if (suppressed != null) {
            e.addSuppressed(suppressed);
        }
        throw e;
    }
}

この例では、最初に発生した例外を抑制するのではなく、次に発生した例外に追加する形で処理しています。これにより、すべての例外情報が保持されます。

finallyブロック内でのエラーハンドリングは慎重に行い、リソースのクリーンアップを確実に行うと同時に、例外の情報を失わないようにすることが重要です。これらのベストプラクティスを守ることで、プログラムの信頼性を向上させることができます。

finallyブロックの注意点と落とし穴

finallyブロックは、リソースのクリーンアップや必須の処理を確実に行うための強力なツールですが、使用にあたっては注意すべき点や落とし穴も存在します。これらのポイントを理解することで、finallyブロックをより安全かつ効果的に使用できます。

1. finallyブロック内でのリターン

finallyブロック内でreturn文を使用すると、tryやcatchブロック内のreturn文が無視されることになります。これにより、プログラムの制御フローが予期せぬ結果になる可能性があります。

public int exampleMethod() {
    try {
        return 1;
    } finally {
        return 2;
    }
}

この例では、tryブロック内のreturn 1;が無視され、メソッドは2を返します。finallyブロックでのreturnは避けるべきであり、必要であれば他の方法で処理を行うようにしましょう。

2. finallyブロック内での例外の無視

finallyブロック内で例外が発生すると、その例外が無視されるか、tryまたはcatchブロック内で発生した例外を上書きしてしまう可能性があります。これにより、本来報告されるべき重要な例外情報が失われてしまうことがあります。

try {
    throw new Exception("Initial Exception");
} finally {
    throw new RuntimeException("Finally Block Exception");
}

この例では、finallyブロック内の例外がtryブロック内の例外を上書きしてしまい、元の例外情報が失われます。finallyブロック内では、例外を発生させないか、適切にキャッチして処理することが重要です。

3. finallyブロックのパフォーマンスへの影響

finallyブロックは必ず実行されるため、そこで行われる処理はプログラム全体のパフォーマンスに直接影響を与える可能性があります。特に、重い処理や複雑なロジックをfinallyブロックに含めると、プログラムのパフォーマンスが低下するリスクがあります。

finallyブロックには、リソースのクローズや簡単なログ記録など、シンプルで軽量な処理のみを含めるようにしましょう。

4. try-with-resources構文の代替としての使用

Java 7以降では、try-with-resources構文を使用することで、リソース管理が自動化され、finallyブロックを明示的に書く必要がなくなりました。古いコードではfinallyブロックが使われているかもしれませんが、可能であればtry-with-resourcesに置き換えることで、コードの可読性と安全性を向上させることができます。

try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
    // ファイルの処理
} catch (IOException e) {
    e.printStackTrace();
}

このように、finallyブロックを使用せずにリソースの自動解放を実現できます。

5. finallyブロック内での再代入

finallyブロック内で変数の再代入を行うと、その変数が持つ元の値が失われ、予期しない動作を引き起こすことがあります。特に、例外やリソースのクローズ状態を追跡している変数に対して再代入を行うと、問題が発生する可能性が高いです。

BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("example.txt"));
    // ファイルの処理
} catch (IOException e) {
    e.printStackTrace();
} finally {
    br = null; // 再代入によりリソースをクローズする機会を失う
}

このような再代入は避け、finallyブロックでは必要最低限の処理を行うようにしましょう。

これらの注意点を理解し、適切に対応することで、finallyブロックを安全かつ効果的に利用することができ、Javaプログラムの品質をさらに向上させることができます。

finallyブロックを使った具体例

finallyブロックは、Javaで例外が発生したかどうかに関係なく、必ず実行されるコードを記述するために使用されます。ここでは、finallyブロックを使ってリソースをクリーンアップする具体的なコード例をいくつか紹介し、その動作を解説します。

ファイルの読み込みとクローズ

以下は、ファイルを読み込み、その後にファイルリソースを確実にクローズするためにfinallyブロックを使用した例です。

import java.io.*;

public class FinallyExample {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.err.println("Error closing file: " + e.getMessage());
            }
        }
    }
}

コードの解説

  • tryブロック内で、BufferedReaderを使用してファイルexample.txtを読み込みます。
  • catchブロックで、FileNotFoundExceptionやIOExceptionが発生した場合にそれぞれの例外を処理します。
  • finallyブロックで、BufferedReaderを確実にクローズするようにしています。このブロックは、tryブロックで例外が発生した場合でも必ず実行されます。

この例では、finallyブロックを使用することで、ファイルが確実に閉じられ、リソースリークを防ぐことができます。

データベース接続のクローズ

データベース接続を扱う際にも、finallyブロックを使って接続を確実に閉じることが重要です。以下は、その具体例です。

import java.sql.*;

public class DatabaseConnectionExample {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/testdb", "user", "password");
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT * FROM users");

            while (rs.next()) {
                System.out.println("User: " + rs.getString("username"));
            }
        } catch (SQLException e) {
            System.err.println("Database error: " + e.getMessage());
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (stmt != null) {
                    stmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}

コードの解説

  • tryブロック内で、データベースに接続し、クエリを実行して結果を取得します。
  • catchブロックで、SQLExceptionをキャッチし、エラーメッセージを出力します。
  • finallyブロックで、ResultSet、Statement、およびConnectionをクローズします。これにより、データベースリソースが確実に解放され、接続が終了します。

この例でも、finallyブロックによってリソースリークを防ぐことができます。特にデータベース接続はシステムリソースを消費するため、クローズしないと重大なパフォーマンス問題を引き起こす可能性があります。

カスタムリソースのクリーンアップ

独自のリソース管理が必要な場合にも、finallyブロックを使用してクリーンアップ処理を行うことができます。以下に、カスタムリソースをクリーンアップする例を示します。

class CustomResource {
    public void open() {
        System.out.println("Resource opened.");
    }

    public void close() {
        System.out.println("Resource closed.");
    }
}

public class CustomResourceExample {
    public static void main(String[] args) {
        CustomResource resource = null;
        try {
            resource = new CustomResource();
            resource.open();
            // リソースの使用
        } finally {
            if (resource != null) {
                resource.close();
            }
        }
    }
}

コードの解説

  • CustomResourceクラスには、open()とclose()メソッドが定義されています。
  • tryブロック内でリソースを開き、使用します。
  • finallyブロックで、リソースがnullでない場合にクローズ処理を行います。

このように、カスタムリソースでもfinallyブロックを使って安全にクリーンアップを行うことができます。

これらの具体例を通じて、finallyブロックの有効な使い方とその効果を理解し、Javaプログラムでのリソース管理を確実に行うことができるようになります。

finallyブロックを用いたクリーンアップの演習問題

Javaのfinallyブロックを使って、リソースのクリーンアップを行う練習をしてみましょう。以下の演習問題では、実際にコードを書いてみることで、finallyブロックの理解を深め、適切なリソース管理方法を習得します。

演習問題1: ファイル読み込みのクリーンアップ

問題:
テキストファイル”data.txt”を読み込み、その内容をコンソールに表示するプログラムを作成してください。ファイルの読み込みに使用するBufferedReaderを、finallyブロックを使って適切にクローズしてください。ファイルが存在しない場合や読み込み中にエラーが発生した場合にも対応するように、例外処理を追加してください。

解答例:

import java.io.*;

public class FileReadExample {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("data.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.err.println("Error closing reader: " + e.getMessage());
            }
        }
    }
}

演習問題2: データベース接続のクリーンアップ

問題:
データベースに接続して、”users”テーブルから全てのユーザー名を取得し、コンソールに表示するプログラムを作成してください。Connection、Statement、およびResultSetの各リソースをfinallyブロックで適切にクローズするようにコードを記述してください。データベース接続やクエリ実行時にエラーが発生した場合の例外処理も追加してください。

解答例:

import java.sql.*;

public class DatabaseCleanupExample {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/testdb", "user", "password");
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT username FROM users");

            while (rs.next()) {
                System.out.println("User: " + rs.getString("username"));
            }
        } catch (SQLException e) {
            System.err.println("Database error: " + e.getMessage());
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (stmt != null) {
                    stmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}

演習問題3: カスタムリソースのクリーンアップ

問題:
カスタムリソースCustomResourceを用いてリソース管理を行うプログラムを作成してください。CustomResourceには、open()およびclose()メソッドがあり、これらのメソッドをfinallyブロックで適切に呼び出してリソースをクリーンアップしてください。

解答例:

class CustomResource {
    public void open() {
        System.out.println("Resource opened.");
    }

    public void close() {
        System.out.println("Resource closed.");
    }
}

public class CustomResourceCleanupExample {
    public static void main(String[] args) {
        CustomResource resource = null;
        try {
            resource = new CustomResource();
            resource.open();
            // リソースの使用
        } finally {
            if (resource != null) {
                resource.close();
            }
        }
    }
}

これらの演習問題を通して、finallyブロックを使ったリソース管理の実践的なスキルを身につけることができます。各問題を解くことで、Javaプログラムでのクリーンアップの重要性とその方法を深く理解することができるでしょう。

まとめ

本記事では、Javaのfinallyブロックを用いたリソースのクリーンアップ方法について詳しく解説しました。finallyブロックは、例外の発生有無にかかわらず、リソースの解放やクリーンアップを確実に行うための重要な機能です。具体的なコード例を通じて、finallyブロックの基本的な使い方から、注意すべきポイント、ベストプラクティス、そしてtry-with-resources構文による自動リソース管理までを学びました。これらの知識を活用することで、Javaプログラムの安定性と効率性を向上させることができるでしょう。リソース管理を適切に行うことが、信頼性の高いソフトウェア開発の基盤となります。

Java
java リソース管理 finallyブロック

コメント

コメントする

目次