it-swarm-id.com

Apakah blok akhirnya selalu dijalankan di Jawa?

Mempertimbangkan kode ini, bisakah saya benar-benar yakin bahwa finally blok selalu dijalankan, tidak peduli apa something() itu?

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

Ya, finally akan dipanggil setelah eksekusi blok kode try atau catch.

Satu-satunya waktu finally tidak akan dipanggil adalah:

  1. Jika Anda memohon System.exit()
  2. Jika JVM crash terlebih dahulu
  3. Jika JVM mencapai infinite loop (atau pernyataan non-interruptable, non-terminating lainnya) di blok try atau catch
  4. Jika OS secara paksa menghentikan proses JVM; mis., kill -9 <pid> pada UNIX
  5. Jika sistem Host mati; mis., kegagalan daya, kesalahan perangkat keras, panik OS, dan lain-lain
  6. Jika blok finally akan dieksekusi oleh daemon thread dan semua utas non-daemon lainnya keluar sebelum finally disebut
2415
jodonnell

Kode contoh:

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.");
    }
}

Keluaran:

finally trumps return. 
0
502
Kevin

Juga, meskipun itu praktik buruk, jika ada pernyataan pengembalian di dalam blok akhirnya, itu akan mengalahkan pengembalian lain dari blok biasa. Artinya, blok berikut ini akan kembali salah:

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

Hal yang sama dengan melempar pengecualian dari blok terakhir.

362
MooBob42

Inilah kata-kata resmi dari Spesifikasi Bahasa Jawa.

14.20.2. Eksekusi try-akhirnya dan try-catch-akhirnya

Pernyataan try dengan blok finally dieksekusi dengan terlebih dahulu mengeksekusi blok try. Lalu ada pilihan:

  • Jika eksekusi blok try selesai secara normal, [...]
  • Jika eksekusi blok try selesai mendadak karena throw dari nilai V, [...]
  • Jika eksekusi blok try selesai tiba-tiba karena alasan lain R, maka blok finally dieksekusi. Lalu ada pilihan:
    • Jika blok akhirnya selesai secara normal, maka pernyataan try tiba-tiba selesai karena alasan R.
    • Jika blok finally selesai secara tiba-tiba karena alasan S, maka pernyataan try diselesaikan secara tiba-tiba karena alasan S ( dan alasan R dibuang ).

Spesifikasi untuk return sebenarnya membuat ini eksplisit:

JLS 14.17 Pernyataan pengembalian

ReturnStatement:
     return Expression(opt) ;

Pernyataan return tanpa Expression upaya untuk mentransfer kontrol ke penyerang metode atau konstruktor yang berisi itu.

Pernyataan return dengan Expression upaya untuk mentransfer kontrol ke penyerang metode yang berisi itu; nilai Expression menjadi nilai dari pemanggilan metode.

Deskripsi sebelumnya mengatakan " upaya untuk mentransfer kontrol" daripada hanya "transfer kontrol" karena jika ada pernyataan try dalam metode atau konstruktor yang try bloknya berisi pernyataan return, maka setiap klausa finally dari pernyataan try tersebut akan dieksekusi, agar, paling terdalam ke terluar, sebelum kontrol ditransfer ke penyerang metode atau konstruktor. Penyelesaian klausa finally secara mendadak dapat mengganggu transfer kontrol yang diprakarsai oleh pernyataan return.

249

Selain tanggapan lain, penting untuk menunjukkan bahwa 'akhirnya' memiliki hak untuk mengganti nilai pengecualian/dikembalikan oleh blok try..catch. Misalnya, kode berikut mengembalikan 12:

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

Demikian pula, metode berikut ini tidak membuang pengecualian:

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

Sementara metode berikut tidak membuangnya:

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

Saya mencoba contoh di atas dengan sedikit modifikasi-

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.");
    }
}

Output kode di atas:

akhirnya mengalahkan kembali.
2

Ini karena ketika return i; dieksekusi i memiliki nilai 2. Setelah ini blok finally dieksekusi di mana 12 ditugaskan ke i dan kemudian System.out out dieksekusi.

Setelah menjalankan blok finally, blok try mengembalikan 2, bukan mengembalikan 12, karena pernyataan pengembalian ini tidak dieksekusi lagi.

Jika Anda akan men-debug kode ini di Eclipse maka Anda akan merasa bahwa setelah mengeksekusi System.out dari finally blok, pernyataan return blok try dieksekusi lagi. Tapi ini bukan masalahnya. Ini hanya mengembalikan nilai 2.

109
vibhash

Inilah uraian jawaban Kevin . Penting untuk mengetahui bahwa ekspresi yang akan dikembalikan dievaluasi sebelum finally, bahkan jika itu dikembalikan setelah.

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");
    }
}

Keluaran:

X
finally trumps return... sort of
0
95
WoodenKitty

Itulah seluruh gagasan tentang blok akhirnya. Ini memungkinkan Anda memastikan Anda melakukan pembersihan yang mungkin dilewati karena Anda kembali, antara lain, tentu saja.

Akhirnya dipanggil terlepas dari apa yang terjadi di blok coba ( kecuali Anda panggil System.exit(int) atau Java Virtual Machine cocok karena alasan lain).

52
Chris Cooper

Cara logis untuk memikirkan ini adalah:

  1. Kode yang ditempatkan di blok akhirnya harus dijalankan apa pun yang terjadi dalam blok coba
  2. Jadi, jika kode di blok percobaan mencoba mengembalikan nilai atau melemparkan pengecualian, item ditempatkan 'di rak' hingga blok akhirnya dapat dieksekusi
  3. Karena kode di blok terakhir memiliki (menurut definisi) prioritas tinggi dapat mengembalikan atau membuang apa pun yang disukainya. Dalam hal apa pun yang tersisa 'di rak' dibuang.
  4. Satu-satunya pengecualian untuk ini adalah jika VM dimatikan sepenuhnya selama blok coba mis. oleh 'System.exit'
38
Garth Gilmour

akhirnya selalu dieksekusi kecuali ada penghentian program abnormal (seperti memanggil System.exit (0) ..). jadi, sysout Anda akan dicetak

18
shyam

Kembali juga akhirnya akan membuang pengecualian. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

18

Blok akhirnya selalu dieksekusi kecuali ada penghentian program yang tidak normal, baik yang dihasilkan dari crash JVM atau dari panggilan ke System.exit(0).

Selain itu, nilai apa pun yang dikembalikan dari dalam blok akhirnya akan menggantikan nilai yang dikembalikan sebelum eksekusi blok akhirnya, jadi berhati-hatilah memeriksa semua titik keluar saat menggunakan coba akhirnya.

17
user9189

Tidak, tidak selalu satu kasus pengecualian adalah // System.exit (0); sebelum akhirnya blok mencegah akhirnya dieksekusi.

  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");
        }
    }
}
17
Rajendra Jadi

Akhirnya selalu dijalankan itulah intinya, hanya karena itu muncul dalam kode setelah pengembalian tidak berarti bahwa itulah yang diterapkan. Java runtime memiliki tanggung jawab untuk menjalankan kode ini ketika keluar dari blok try.

Misalnya jika Anda memiliki yang berikut ini:

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

Runtime akan menghasilkan sesuatu seperti ini:

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

Jika eksepsi yang tidak tertangkap dilemparkan blok finally akan berjalan dan eksepsi akan terus merambat.

12
Motti

Ini karena Anda menetapkan nilai i sebagai 12, tetapi tidak mengembalikan nilai i ke fungsi. Kode yang benar adalah sebagai berikut:

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

Karena akhirnya blok akan selalu dipanggil kecuali jika Anda memanggil System.exit() (atau utas macet).

9
Jay Riggs

Jawabannya sederhanaYA.

MEMASUKKAN:

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");
}

OUTPUT:

catch
finally
9
Meet

Ya itu akan dipanggil. Itulah inti dari akhirnya memiliki kata kunci. Jika melompat dari blok coba/tangkap hanya bisa melewati blok akhirnya itu sama dengan menempatkan System.out.println di luar coba/tangkap.

8
Mendelt

Ya, akhirnya blok selalu dijalankan. Sebagian besar pengembang menggunakan blok ini untuk menutup koneksi database, objek resultset, objek pernyataan dan juga menggunakan hibernate Java untuk mengembalikan transaksi.

8
Gautam Viradiya

Singkatnya, dalam Dokumentasi resmi Java (Klik di sini ), tertulis bahwa -

Jika JVM keluar saat kode coba atau tangkap dijalankan, maka blok akhirnya mungkin tidak dapat dijalankan. Demikian juga, jika utas yang menjalankan kode coba atau tangkap terganggu atau terbunuh, blok akhirnya mungkin tidak dapat dijalankan meskipun aplikasi secara keseluruhan berlanjut.

8
bikz05

Ya, tentu saja. Satu-satunya hal yang tidak akan terjadi adalah JVM keluar atau macet

7
abhig

Ya, tentu saja. Apa pun yang terjadi dalam blok coba atau tangkap Anda kecuali jika System.exit () dipanggil atau JVM lumpuh. jika ada pernyataan kembali di blok, akhirnya akan dieksekusi sebelum pernyataan kembali itu.

7
Karthikeyan

Pertimbangkan program berikut:

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");
        }
    }
}

Pada Java 1.8.162, blok kode di atas memberikan output berikut:

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

ini berarti menggunakan finally untuk membebaskan objek adalah praktik yang baik seperti kode berikut:

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.
    }
}
7
Samim

Saya mencoba ini, ini adalah utas tunggal.

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");
       }
   }
}

Utas utama akan menunggu selamanya, maka akhirnya tidak akan pernah dipanggil,

jadi output konsol tidak akan mencetak string: after wait() atau finally

Setuju dengan @Stephen C, contoh di atas adalah salah satu dari 3 kasus yang menyebutkan di sini :

Menambahkan beberapa kemungkinan loop tak terhingga dalam kode berikut:

// 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");
        }
    }
}

Kasus 2: Jika JVM crash terlebih dahulu

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: Bagaimana Anda menabrak JVM?

Kasus 6: Jika akhirnya blok akan dieksekusi oleh daemon thread dan semua thread non-daemon lainnya keluar sebelum akhirnya dipanggil.

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("-------------------------------------------------");
    }
}

output: Ini tidak mencetak "akhirnya" yang menyiratkan "Akhirnya blok" di "daemon thread" tidak dijalankan

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
6
dkb

Ya, karena tidak ada pernyataan kontrol dapat mencegah finally dieksekusi.

Ini adalah contoh referensi, di mana semua blok kode akan dieksekusi:

| 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      |

Pada varian di bawah ini, return x; akan dilewati. Hasilnya masih 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--;
    }
}

Referensi, tentu saja, melacak status mereka. Contoh ini mengembalikan referensi dengan 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
    }
}
6
Dávid Horváth

finally akan mengeksekusi dan itu sudah pasti.

finally tidak akan dieksekusi dalam kasus di bawah ini:

kasus 1 :

Saat Anda menjalankan System.exit().

kasus 2:

Saat JVM/Thread Anda mogok.

kasus 3:

Ketika eksekusi Anda dihentikan di antara secara manual.

6
Utkash Bhatt

try- catch- finally adalah kata-kata kunci untuk menggunakan case handling pengecualian.
Sebagai penjelasan biasa

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
}

Blok akhirnya mencegah eksekusi ...

  • Ketika Anda menelepon System.exit(0);
  • Jika JVM keluar.
  • Kesalahan dalam JVM
6

Jika Anda tidak menangani pengecualian, sebelum menghentikan program, JVM mengeksekusi akhirnya memblokir. Ini tidak akan dieksekusi hanya jika eksekusi normal program akan gagal penghentian program karena alasan berikut.

  1. Dengan menyebabkan kesalahan fatal yang menyebabkan proses dibatalkan.

  2. Penghentian program karena memori rusak.

  3. Dengan memanggil System.exit ()

  4. Jika program masuk ke loop infinity.

6

Itu sebenarnya benar dalam bahasa apa pun ... akhirnya akan selalu dijalankan sebelum pernyataan kembali, tidak peduli di mana pengembalian itu ada di tubuh metode. Jika bukan itu masalahnya, blok akhirnya tidak akan memiliki banyak arti.

6
Scott Dorman

Menambahkan ke @ vibhash's answer karena tidak ada jawaban lain yang menjelaskan apa yang terjadi dalam kasus objek yang bisa berubah seperti di bawah ini.

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 ");
    }
}

Akan menghasilkan

sbupdated 
6

Ya, ada tertulis di sini

Jika JVM keluar saat kode coba atau tangkap dijalankan, maka blok akhirnya mungkin tidak dapat dijalankan. Demikian juga, jika utas yang menjalankan kode coba atau tangkap terganggu atau terbunuh, blok akhirnya mungkin tidak dapat dijalankan meskipun aplikasi secara keseluruhan berlanjut.

5

Selain poin tentang pengembalian akhirnya mengganti pengembalian di blok percobaan, hal yang sama berlaku untuk pengecualian. Blok akhirnya yang melempar pengecualian akan menggantikan pengembalian atau pengecualian yang dilemparkan dari dalam blok try.

5
Alex Miller

TIDAK SELALU

Spesifikasi Bahasa Jawa menjelaskan cara kerja try-catch-akhirnya dan try-catch blocks di 14.20.2
Di mana pun ia tidak menentukan bahwa blok akhirnya selalu dieksekusi. Tetapi untuk semua kasus di mana blok coba-tangkap-akhirnya dan coba-akhirnya selesai itu tidak menentukan bahwa sebelum penyelesaian akhirnya harus dijalankan.

try {
  CODE inside the try block
}
finally {
  FIN code inside finally block
}
NEXT code executed after the try-finally block (may be in a different method).

JLS tidak menjamin bahwaFINdijalankan setelahCODE. JLS menjamin bahwa jikaKODEdanBERIKUTNYAdieksekusi makaFINakan selalu dieksekusi setelahKODEdan sebelumSELANJUTNYA.

Mengapa JLS tidak menjamin bahwa blok akhirnya selalu dijalankan setelah blok coba? Karena itu tidak mungkin. Tidak mungkin tetapi mungkin bahwa JVM akan dibatalkan (kill, crash, power off) tepat setelah menyelesaikan blok try tetapi sebelum eksekusi blok akhirnya. Tidak ada yang bisa dilakukan JLS untuk menghindari ini.

Dengan demikian, setiap perangkat lunak yang untuk perilaku yang tepat tergantung pada akhirnya blok selalu dieksekusi setelah blok percobaan mereka selesai disadap.

Pengembalian di blok percobaan tidak relevan dengan masalah ini. Jika eksekusi mencapai kode setelah try-catch-akhirnya dijamin bahwa blok akhirnya akan dieksekusi sebelumnya, dengan atau tanpa pengembalian di dalam blok coba.

Blok akhirnya tidak akan dipanggil setelah kembali dalam beberapa skenario unik: jika System.exit () dipanggil terlebih dahulu, atau jika JVM lumpuh.

Biarkan saya mencoba menjawab pertanyaan Anda dengan cara termudah.

Aturan 1 : Blok akhirnya selalu berjalan (Meskipun ada pengecualian untuk itu. Tapi mari kita tetap berpegang pada ini untuk beberapa saat.)

Aturan 2 : pernyataan di blok akhirnya berjalan ketika kontrol meninggalkan mencoba atau menangkap blok. Transfer kontrol dapat terjadi sebagai hasil dari eksekusi normal, eksekusi break, continue, goto atau pernyataan pengembalian, atau propogasi pengecualian.

Dalam kasus pernyataan kembali secara khusus (karena keterangannya), kontrol harus meninggalkan metode pemanggilan, Dan karenanya memanggil blok akhirnya dari struktur try-akhirnya yang sesuai. Pernyataan pengembalian dieksekusi setelah blok akhirnya.

Jika ada pernyataan kembali di blok terakhir juga, itu pasti akan menimpa yang tertunda di blok coba, karena itu membersihkan tumpukan panggilan.

Anda dapat merujuk penjelasan yang lebih baik di sini: http://msdn.Microsoft.com/en-us/ .... konsepnya kebanyakan sama di semua bahasa tingkat tinggi.

5
Sandip Solanki
  1. Akhirnya Block selalu dieksekusi. Kecuali dan sampai System.exit () pernyataan ada di sana (pernyataan pertama di blok akhirnya).
  2. Jika system.exit () adalah pernyataan pertama maka akhirnya blok tidak akan dieksekusi dan kontrol keluar dari blok akhirnya. Kapan saja pernyataan System.exit () masuk akhirnya memblokir sampai pernyataan itu akhirnya memblokir dieksekusi dan ketika System.exit () muncul maka kontrol sepenuhnya muncul dari blok akhirnya.
5
Avinash Pande

Sama dengan kode berikut:

static int f() {
    while (true) {
        try {
            return 1;
        } finally {
            break;
        }
    }
    return 2;
}

f akan mengembalikan 2!

4
dibo

Karena final selalu dipanggil dalam kasus apa pun yang Anda miliki. Anda tidak memiliki pengecualian, masih dipanggil, tangkap pengecualian, masih disebut

4
vodkhang

Ya itu akan selalu dipanggil tetapi dalam satu situasi itu tidak memanggil ketika Anda menggunakan System.exit ()

try{
//risky code
}catch(Exception e){
//exception handling code
}
finally(){
//It always execute but before this block if there is any statement like System.exit(0); then this block not execute.
}
4

Akhirnya blok selalu mengeksekusi apakah pengecualian menangani atau tidak.

4
Rohit Chugh

Jika pengecualian dilemparkan, akhirnya berjalan. Jika pengecualian tidak dilempar, akhirnya berjalan. Jika pengecualian tertangkap, akhirnya berjalan. Jika pengecualian tidak tertangkap, akhirnya berjalan.

Hanya waktu itu tidak berjalan adalah ketika JVM keluar.

4
Bhushan

Pertimbangkan ini dalam proses eksekusi normal (yaitu tanpa Pengecualian): jika metode tidak 'dibatalkan' maka selalu secara eksplisit mengembalikan sesuatu, namun, akhirnya selalu dieksekusi

4
Gala101

Coba kode ini, Anda akan memahami kode pada akhirnya blok dijalankan setelah pernyataan kembali .

public class TestTryCatchFinally {
    static int x = 0;

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

    public static int f1(){
        try{
            x = 1;
            return x;
        }finally{
            x = 2;
        }
    }

    public static int f2(){
        return x;
    }
}
4
eric2323223

Saya sangat bingung dengan semua jawaban yang diberikan di forum yang berbeda dan akhirnya memutuskan untuk kode dan melihat. Ouput adalah:

akhirnya akan dieksekusi meskipun ada return in try and catch block.

try {  
  System.out.println("try"); 
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} catch (Exception e) {   
  System.out.println("catch");
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} finally {  
   System.out.println("Print me FINALLY");
}

Output

mencoba

Cetak saya AKHIRNYA

  1. Jika return digantikan oleh System.exit(0) di coba dan tangkap blok dalam kode di atas dan pengecualian terjadi sebelumnya, dengan alasan apa pun.
4
milton

akhirnya juga bisa keluar sebelum waktunya jika pengecualian dilemparkan di dalam blok bersarang akhirnya. Compiler akan memperingatkan Anda bahwa blok akhirnya tidak selesai secara normal atau memberikan kesalahan bahwa Anda memiliki kode yang tidak terjangkau. Kesalahan untuk kode yang tidak terjangkau hanya akan ditampilkan jika lemparan tidak berada di belakang pernyataan kondisional atau di dalam loop.

try{
}finally{
   try{
   }finally{
      //if(someCondition) --> no error because of unreachable code
      throw new RunTimeException();
   }
   int a = 5;//unreachable code
}
3
HopefullyHelpful

Akhirnya selalu dipanggil di akhir

ketika Anda mencoba, itu mengeksekusi beberapa kode, jika sesuatu terjadi dalam coba, maka catch akan menangkap pengecualian itu dan Anda bisa mencetak beberapa mssg atau membuang kesalahan, kemudian akhirnya blok dieksekusi.

Akhirnya biasanya digunakan ketika melakukan pembersihan, misalnya, jika Anda menggunakan pemindai di Jawa, Anda mungkin harus menutup pemindai karena mengarah ke masalah lain seperti tidak dapat membuka beberapa file

2
Rubin Luitel

akhirnya blok dieksekusi selalu bahkan jika Anda meletakkan pernyataan return di blok try. Blok akhirnya akan dieksekusi sebelum pernyataan kembali.

2
Sabrina