Mengapa kami menggunakan blok terakhir?

Sejauh yang saya tahu, kedua potongan kode berikut akan melayani tujuan yang sama. Mengapa harus ada finallyblok?

Kode A:

try { /* Some code */ }
catch { /* Exception handling code */ }
finally { /* Cleanup code */ }

Kode B:

try { /* Some code */ }
catch { /* Exception handling code */ }
// Cleanup code

• Apa yang terjadi jika pengecualian yang tidak Anda tangani dilemparkan? (Saya harap Anda tidak menangkap Throwable...)
• Apa yang terjadi jika Anda kembali dari dalam blok percobaan?
• Apa yang terjadi jika blok catch melontarkan pengecualian?

Sebuah finallyblok memastikan bahwa bagaimanapun Anda keluar dari blok itu (modulo beberapa cara untuk membatalkan seluruh proses secara eksplisit), itu akan dieksekusi. Itu penting untuk pembersihan sumber daya secara deterministik.

Perhatikan bahwa (setidaknya di Java, mungkin juga di C #) juga memungkinkan untuk memiliki tryblok tanpa catch, tetapi dengan a finally. Ketika pengecualian terjadi di tryblok, kode di finallyblok dijalankan sebelum pengecualian dilemparkan lebih tinggi:

InputStream in = new FileInputStream("somefile.xyz");
try {
    somethingThatMightThrowAnException();
}
finally {
    // cleanup here
    in.close();
}

Anda mungkin ingin meletakkan kode yang Anda inginkan agar tetap dieksekusi terlepas dari apa yang terjadi di blok coba atau tangkap Anda.

Juga jika Anda menggunakan banyak tangkapan dan jika Anda ingin meletakkan beberapa kode yang umum untuk semua blok tangkapan ini akan menjadi tempat untuk meletakkan - tetapi Anda tidak dapat memastikan bahwa seluruh kode yang dicoba telah dieksekusi.

Sebagai contoh:

conn c1 = new connection();
try {
    c1.dosomething();
} catch (ExceptionA exa) {
    handleexA();
    //c1.close();
} catch (ExceptionB exb) {
    handleexB();
    //c1.close();
} finally {
    c1.close();
}

Akhirnya selalu dieksekusi, sedangkan kode Anda setelah tangkapan mungkin tidak.

Meskipun aplikasi kita ditutup secara paksa akan ada beberapa tugas, yang harus kita jalankan (seperti pelepasan memori, menutup database, kunci rilis, dll), jika Anda menulis baris kode ini di finallyblok, itu akan dijalankan apakah pengecualian dilemparkan atau tidak...

Aplikasi Anda mungkin kumpulan utas, Exceptionmengakhiri utas tetapi tidak seluruh aplikasi, dalam hal finallyini lebih berguna.

Dalam beberapa kasus finallytidak dapat dijalankan seperti JVM Fail, Thread terminate, dll.

Karena Anda memerlukan kode itu untuk dieksekusi terlepas dari pengecualian apa pun yang mungkin dilemparkan. Misalnya, Anda mungkin perlu membersihkan beberapa sumber daya yang tidak terkelola (konstruksi 'using' mengkompilasi ke blok coba / akhirnya).

Mungkin ada saatnya Anda ingin mengeksekusi sepotong kode apa pun yang terjadi. Apakah pengecualian dilempar atau tidak. Kemudian seseorang menggunakan finally.

finallySELALU dijalankan, kecuali JVM dimatikan, finallyhanya menyediakan metode untuk meletakkan kode pembersihan di satu tempat.

Akan sangat membosankan jika Anda harus meletakkan kode pembersihan di setiap catchblok.

Jika blok tangkap mengeluarkan pengecualian apa pun maka kode yang tersisa tidak akan dieksekusi sehingga kita harus menulis blok terakhir.

Akhirnya blok di java dapat digunakan untuk meletakkan kode "pembersihan" seperti menutup file, menutup koneksi dll.

Blok terakhir tidak akan dijalankan jika program keluar (baik dengan memanggil System.exit () atau dengan menyebabkan kesalahan fatal yang menyebabkan proses dibatalkan).

Masih menggulir ke bawah? Ini dia!

Pertanyaan ini memberi saya waktu yang sulit beberapa saat.

try
{
 int a=1;
 int b=0;
 int c=a/b;
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}
finally
{
 console.writeline("Finally block");
}
console.writeline("After finally");

apa yang akan dicetak dalam skenario di atas? Ya, tebak dengan benar:

• mis. Pesan - apa pun itu (mungkin mencoba membagi dengan nol)

• Terakhir blok

• Setelah akhirnya

  try
  {
      int a=1;
      int b=0;
      int c=a/b;
  }
  catch(Exception ex)
  {
      throw(ex);
  }
  finally
  {
      console.writeline("Finally block");
  }
  console.writeline("After finally");
  

Apa yang akan dicetak ini? Tidak ada! Itu melempar kesalahan karena blok tangkap memunculkan kesalahan.

Dalam struktur pemrograman yang baik, pengecualian Anda akan disalurkan, dalam artian kode ini akan ditangani dari lapisan lain. Untuk merangsang kasus seperti itu saya akan mencoba kode ini bersarang.

try
{    
 try
    {
     int a=1;
     int b=0;
     int c=a/b;
    }
    catch(Exception ex)
    {
     throw(ex);
    }
    finally
    {
     console.writeline("Finally block")
    }
    console.writeline("After finally");
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}

Dalam hal ini, hasilnya adalah:

• Terakhir blok
• ex.Message - apapun itu.

Jelas bahwa ketika Anda menangkap pengecualian dan melemparkannya lagi ke lapisan lain (Funneling), kode setelah lemparan tidak dijalankan. Kerjanya mirip dengan bagaimana pengembalian di dalam suatu fungsi bekerja.

Anda sekarang tahu mengapa tidak menutup sumber daya Anda pada kode setelah blok catch. Tempatkan mereka di blok terakhir.