は最後にブロックは常に実行されるJava?

https://stackoverflow.com/questions/65035

09-06-2019
|

質問

このコードできます んだよ その finally ブロックは常に実行など something() す。

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("I don't know if this will get printed out");
}

解決

あり finally 終了後の実行 try または catch コードブロックとなります。

の回数だけ finally なと呼ばれている:

ま呼び出し System.exit()
場合、JVM初のクラッシュ
場合、JVMが無限ループやその他の非interruptable、非終端計算書） try または catch ブロック
の場合はOSに強制的に終了し、JVMプロセス例えば、 kill -9 <pid> UNIX
の場合はホストシステム金型例えば、電源の故障、ハードウェアの誤り、OSのパニック、など
の場合 finally ブロックが実行されるデーモンスレッド以外のすべてのデーモンスレッドの出口前 finally と呼ばれ

他のヒント

例コード:

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int test() {
    try {
        return 0;
    }
    finally {
        System.out.println("finally trumps return.");
    }
}

出力：

finally trumps return. 
0

また、この実践がある場合は戻り算書の最後にブロックとトランプその他に通常のブロックです。それは、以下のブロックがfalseを返します。

try { return true; } finally { return false; }

同じ物を投げから例外がスローされる場合は、最後にブロックです。

この言葉からは、"Java言語仕様となります。

14.20.2.執行う-では最後に、try-catch-では最後に

A try 決算し finally ブロックを実行する最初の実行 try ブロックです。それがあります:

場合の実行 try ブロックの完了通常、[...]

場合の実行 try ブロックの完了の急激な throw の価値 V, [...]

場合の実行 try ブロックの完了で急激にその他の理由により R, その finally ブロックを実行します。それがあります:

の場合は最後にブロックの完了通常、その後の try 文の完了急のための理由 R.

の場合 finally ブロックが完了急のための理由 S, その try 文の完了急のための理由 S (との理由 R は破棄されます).

の仕様 return 実はこの明示的な:

環太平洋の14.17を返し計算書

ReturnStatement:
     return Expression(opt) ;
A return 決算no Expression 試み転送制御の呼び出しの方法またはコンストラクタが含まれます。

A return 決算例 Expression 試み転送制御の呼び出し側のメソッドを含んでの値 Expression となりの価値のメソッドの呼び出し.

先の説明の"ということを試み転送制御"だけではなく"振制御"めがある場合 try 諸表の方法またはコンストラクタが try ブロックを含む return 算書、その他 finally 条項の try 算が実行されたものから順に、奥には一番外側の前に、制御の呼び出しの方法またはコンストラクタです。急激なが完成 finally 項絶の移動の制御が開始した return ます。

また、その他の対応が重要であると指摘してい'このオーバーライド例外/返される値のみ..catchブロックです。例えば、次のコードを返します12:

public static int getMonthsInYear() {
    try {
        return 10;
    }
    finally {
        return 12;
    }
}

同様に、次のメソッドは例外をスローす:

public static int getMonthsInYear() {
    try {
        throw new RuntimeException();
    }
    finally {
        return 12;
    }
}

ながら、以下の方法が定められているので注意が必要で:

public static int getMonthsInYear() {
    try {
        return 12;          
    }
    finally {
        throw new RuntimeException();
    }
}

また、上記の例と若干の変更-

public static void main(final String[] args) {
    System.out.println(test());
}

public static int test() {
    int i = 0;
    try {
        i = 2;
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
    }
}

上記のコードを出力:

最後にtrumpsを返します。
2

この return i; 実行される i の値が2.その後、 finally ブロックを実行が12が割り当てられ i その System.out 出しが実行されます。

実行後の finally ブロックの try ブロックを返します2より帰国12ので、この戻りが実行されません。

またデバッグのこのコードをEclipseでしょうかを感じることを実行した後、 System.out の finally ブロックの return 計算書 try ブロックが実行されます。でも実際はそうではありません。その値を返します2.

こちらの精緻ケビンおじさんの答え.このことを知らない表現で返される評価の前 finally, 場合でも、このプロバイダが返されます。

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int printX() {
    System.out.println("X");
    return 0;
}

public static int test() {
    try {
        return printX();
    }
    finally {
        System.out.println("finally trumps return... sort of");
    }
}

出力：

X
finally trumps return... sort of
0

その発想では考えられない、最後にブロックです。できいいの清掃活動はそれをスキップししますので、どのコースです。

最後にが呼び出され を問わず起こることから は、tryブロックない限り 呼び出す System.exit(int) または、Java仮想マシンをキックしてその他の理由).

論理的に考えていただきたいところです:

コードされたブロックを実行しなければな 何が起こ 内tryブロック
そのコードは、tryブロックを返す値または例外をスローする項目が配置され、棚"では、最後にブロックを実行することができ
でコードの最後にブロック（定義）は、優先度の高い戻すことができたげんできました。その場合も左"本棚"が破棄されます。
唯一の例外があるが、その場合、VMシャットダウンすると完全に中tryブロック例によるシステム。exit'

また、返却後まで捨ます。 http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

最後には常に実行されないのであれば異常なプログラムの終了時のように呼び出します。exit(0)..).なので、おsysoutまま印刷

の最後にブロックは常に実行されないのであれば異常なプログラムの終了いずれかによるJVMクラッシュからの呼び出し System.exit(0).

その上で、返される値からの最後にブロックをオーバーライドから返された値以前の実行の最後にブロックするように注意してくださいチェックすべての出ポイント利用時のみでした。

いいえ、必ずしも一つの例外の場合は// システム。exit(0);前の最後にブロックを防ぐために実行されます。

  class A {
    public static void main(String args[]){
        DataInputStream cin = new DataInputStream(System.in);
        try{
            int i=Integer.parseInt(cin.readLine());
        }catch(ArithmeticException e){
        }catch(Exception e){
           System.exit(0);//Program terminates before executing finally block
        }finally{
            System.out.println("Won't be executed");
            System.out.println("No error");
        }
    }
}

最後には常に施設まで格安料金プランをのポイントは、で表示されるコードの後に返却えてくるということではないことになるかを実装します。Java runtimeの責任でこのコードを終了する際に try ブロックです。

たとえば、あるいは，以下のように:

int foo() { 
    try {
        return 42;
    }
    finally {
        System.out.println("done");
    }
}

ランタイムを生成するようなこと:

int foo() {
    int ret = 42;
    System.out.println("done");
    return 42;
}

場合キャッチされない例外がスローされる finally ブロックのとし、例外が続く伝播する.

これは、それぞれの値として12かとなった値を返しのための機能です。正確にコード：

public static int test() {
    int i = 0;
    try {
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
        return i;
    }
}

では最後にブロックは常にない場合は呼び出されま話 System.exit() (またはスレッドのクラッシュ).

答えは簡単あり.

入力：

try{
    int divideByZeroException = 5 / 0;
} catch (Exception e){
    System.out.println("catch");
    return;    // also tried with break; in switch-case, got same output
} finally {
    System.out.println("finally");
}

出力：

catch
finally

ありますの呼び出されます。この点と最後にキーワードとなります。場合にジャンプ台から飛び出すtry/catchブロックがスキップの最後にブロックで同じとしてはシステム。ます。println外ではtry/catch.

簡潔かつ、Javaのドキュメント(クリックこちらので記述する-

場合、JVM口がいくコードが実行され、その後の最後にブロックあたりを実行することを示しています。また、スレッドの実行のみくコードを途中で中断または殺害され、最後にブロック実行されないものとしてアプリケーション全体で続いています。

あり、ついにブロックは常に実行できます。の開発者はこのブロックの終値のデータベース接続には、resultsetオブジェクトのstatementオブジェクトとともに、java hibernateにトランザクションをロールバック.

審査対象になります。かごしてみまたはcatchブロックを除きます。exit()と呼ばれたJVMが暴落した。があった場合は返算書のブロック（s）、最後に実行されることになりそれ以前を返します。

あります。だけではないが、JVM口またはクラッシュ

考えるよう、以下のようなプログラム:

public class SomeTest {

    private static StringBuilder sb = new StringBuilder();

    public static void main(String args[]) {

        System.out.println(someString());
        System.out.println("---AGAIN---");
        System.out.println(someString());
        System.out.println("---PRINT THE RESULT---");
        System.out.println(sb.toString());
    }

    private static String someString() {

        try {
            sb.append("-abc-");
            return sb.toString();

        } finally {
            sb.append("xyz");
        }
    }
}

Java1.8.162、上記のコードブロックを出力：

-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz

これを利用 finally サービス"などは有料のオプを提供するものである良い練習ができ、以下のようなコード:

private static String someString() {

    StringBuilder sb = new StringBuilder();

    try {
        sb.append("abc");
        return sb.toString();

    } finally {
        sb = null; // Just an example, but you can close streams or DB connections this way.
    }
}

ことになるが、実際はそうで、どの言語にも...最後には常に実行する前に戻り、どこに戻すことがでの方法。までになかった場合は、最後にブロックのない意味があります。

finally 実行されることでした。

finally な実行を以下の例:

例1:

きに実行 System.exit().

例2:

がJVM/スレッドがクラッシュします。

例3:

が執り込みを停止することができます間になります。

ない場合は取扱いの例外を終了する前にプログラム、JVMを実行します。で実行されない場合に限り通常のプログラムの実行に失敗しまうの解除プログラムによりこれらの理由..

起こしによる致命的なエラーの原因となる過程を中止.
終了プログラムによるメモリの腐敗した.
を呼び出します。exit()
場合はプログラムが無限ループを実行します。

ありが なし制御文 を防止でき finally が実行されなかった。

こちらは参考例では、すべてのコードブロックを行います:

| x | Current result | Code 
|---|----------------|------ - - -
|   |                |     
|   |                | public static int finallyTest() {
| 3 |                |     int x = 3;
|   |                |     try {
|   |                |        try {
| 4 |                |             x++;
| 4 | return 4       |             return x;
|   |                |         } finally {
| 3 |                |             x--;
| 3 | throw          |             throw new RuntimeException("Ahh!");
|   |                |         }
|   |                |     } catch (RuntimeException e) {
| 4 | return 4       |         return ++x;
|   |                |     } finally {
| 3 |                |         x--;
|   |                |     }
|   |                | }
|   |                |
|---|----------------|------ - - -
|   | Result: 4      |

の変異体は、以下 return x; スキップされます。結果はまだ 4:

public static int finallyTest() {
    int x = 3;
    try {
        try {
            x++;
            if (true) throw new RuntimeException("Ahh!");
            return x; // skipped
        } finally {
            x--;
        }
    } catch (RuntimeException e) {
        return ++x;
    } finally {
        x--;
    }
}

参考文献はもちろん、トラックます。この例では、参照を返しまと value = 4:

static class IntRef { public int value; }
public static IntRef finallyTest() {
    IntRef x = new IntRef();
    x.value = 3;
    try {
        return x;
    } finally {
        x.value++; // will be tracked even after return
    }
}

try- catch- finally をキーワードの使用例外の取り扱います。
通常のexplanotory

try {
     //code statements
     //exception thrown here
     //lines not reached if exception thrown
} catch (Exception e) {
    //lines reached only when exception is thrown
} finally {
    // always executed when the try block is exited
    //independent of an exception thrown or not
}

の最後にブロックを防止を行...

だという System.exit(0);
場合、JVM終了します。
誤差のJVM

加 @vibhashの回答していないその他の答えを説明しその場合は変更可能なオブジェクトの一つです。

public static void main(String[] args) {
    System.out.println(test().toString());
}

public static StringBuffer test() {
    StringBuffer s = new StringBuffer();
    try {
        s.append("sb");
        return s;
    } finally {
        s.append("updated ");
    }
}

出力は、このようになります

sbupdated

また、このでの一部です。

class Test {
    public static void main(String args[]) throws Exception {
       Object obj = new Object();
       try {
            synchronized (obj) {
            obj.wait();
            System.out.println("after wait()");
           }
       } catch (Exception e) {
       } finally {
           System.out.println("finally");
       }
   }
}

のスレッドが待機状態に永遠に従ってしまい、

でコンソール出力な印刷文字列: after wait() または finally

と合意した@スティーブンC、上記の例では3の場合もこちらの:

追加しながら無限ループの可能性を以下のコード:

// import java.util.concurrent.Semaphore;
class Test {
    public static void main(String[] args) {
        try {
            // Thread.sleep(Long.MAX_VALUE);
            // Thread.currentThread().join();
            // new Semaphore(0).acquire();
            // while (true){}
            System.out.println("after sleep join semaphore exit infinite while loop");
        } catch (Exception e) {
        } finally {
            System.out.println("finally");
        }
    }
}

例2:場合、JVM初のクラッシュ

import sun.misc.Unsafe;
import java.lang.reflect.Field;
class Test {
    public static void main(String args[]) {
        try {
            unsafeMethod();
//            Runtime.getRuntime().halt(123);
            System.out.println("After Jvm Crash!");
        } catch (Exception e) {
        } finally {
            System.out.println("finally");
        }
    }

    private static void unsafeMethod() throws NoSuchFieldException, IllegalAccessException {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        unsafe.putAddress(0, 0);
    }
}

Ref: どのようなインターネットでは、JVM?

例6:またブロックが実行されるデーモンスレッド以外のすべてのデーモンスレッドの出口前の最後には呼び出されます。

class Test {
    public static void main(String args[]) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    printThreads("Daemon Thread printing");
                    // just to ensure this thread will live longer than main thread
                    Thread.sleep(10000);
                } catch (Exception e) {
                } finally {
                    System.out.println("finally");
                }
            }
        };
        Thread daemonThread = new Thread(runnable);
        daemonThread.setDaemon(Boolean.TRUE);
        daemonThread.setName("My Daemon Thread");
        daemonThread.start();
        printThreads("main Thread Printing");
    }

    private static synchronized void printThreads(String str) {
        System.out.println(str);
        int threadCount = 0;
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        for (Thread t : threadSet) {
            if (t.getThreadGroup() == Thread.currentThread().getThreadGroup()) {
                System.out.println("Thread :" + t + ":" + "state:" + t.getState());
                ++threadCount;
            }
        }
        System.out.println("Thread count started by Main thread:" + threadCount);
        System.out.println("-------------------------------------------------");
    }
}

出力：このない印刷"最後に"という"ついにブロック"の"デーモンスレッド"な実行

main Thread Printing  
Thread :Thread[My Daemon Thread,5,main]:state:BLOCKED  
Thread :Thread[main,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE   
Thread count started by Main thread:3  
-------------------------------------------------  
Daemon Thread printing  
Thread :Thread[My Daemon Thread,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE  
Thread count started by Main thread:2  
-------------------------------------------------  

Process finished with exit code 0

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow