Mengapa mengubah variabel yang dikembalikan dalam blok akhirnya tidak mengubah nilai balik?

Saya memiliki kelas Java sederhana seperti yang ditunjukkan di bawah ini:

public class Test {

    private String s;

    public String foo() {
        try {
            s = "dev";
            return s;
        } 
        finally {
            s = "override variable s";
            System.out.println("Entry in finally Block");  
        }
    }

    public static void main(String[] xyz) {
        Test obj = new Test();
        System.out.println(obj.foo());
    }
}

Dan output dari kode ini adalah ini:

Entry in finally Block
dev  

Mengapa stidak diganti dalam finallyblok, belum mengontrol hasil cetak?

The tryblok Rampungkan dengan pelaksanaan returnpernyataan dan nilai spada saat returnpernyataan mengeksekusi adalah nilai yang dikembalikan oleh metode ini. Fakta bahwa finallyklausa kemudian mengubah nilai s(setelah returnpernyataan selesai) tidak (pada saat itu) mengubah nilai kembali.

Perhatikan bahwa di atas berkaitan dengan perubahan nilai situ sendiri di finallyblok, bukan ke objek yang sdireferensikan. Jika sreferensi ke objek yang bisa berubah (yang Stringtidak) dan isi objek diubah di finallyblok, maka perubahan itu akan terlihat pada nilai yang dikembalikan.

Aturan terperinci untuk bagaimana semua ini beroperasi dapat ditemukan di Bagian 14.20.2 dari Spesifikasi Bahasa Jawa . Perhatikan bahwa eksekusi returnpernyataan diperhitungkan sebagai penghentian mendadak tryblok (bagian mulai " Jika eksekusi blok coba selesai tiba-tiba karena alasan lain R .... " berlaku). Lihat Bagian 14.17 dari JLS untuk alasan mengapa suatu returnpernyataan tiba-tiba merupakan penghentian blok.

Dengan perincian lebih lanjut: jika tryblok dan finallyblok try-finallypernyataan berakhir tiba-tiba karena returnpernyataan, maka aturan berikut dari §14.20.2 berlaku:

Jika eksekusi tryblok selesai tiba-tiba karena alasan lain R [selain melempar pengecualian], maka finallyblok dieksekusi, dan kemudian ada pilihan:

• Jika finallyblok selesai secara normal, maka trypernyataan selesai tiba-tiba karena alasan R.
• Jika finallyblok selesai tiba-tiba karena alasan S, maka trypernyataan lengkap tiba-tiba karena alasan S (dan alasan R dibuang).

Hasilnya adalah bahwa returnpernyataan di finallyblok menentukan nilai kembali seluruh try-finallypernyataan, dan nilai yang dikembalikan dari tryblok dibuang. Hal serupa terjadi dalam try-catch-finallypernyataan jika tryblok melempar pengecualian, ditangkap oleh catchblok, dan baik catchblok maupun finallyblok memiliki returnpernyataan.

Karena nilai balik diletakkan di tumpukan sebelum panggilan ke akhirnya.

Jika kita melihat ke dalam bytecode, kita akan melihat bahwa JDK telah membuat optimasi yang signifikan, dan metode foo () terlihat seperti:

String tmp = null;
try {
    s = "dev"
    tmp = s;
    s = "override variable s";
    return tmp;
} catch (RuntimeException e){
    s = "override variable s";
    throw e;
}

Dan bytecode:

0:  ldc #7;         //loading String "dev"
2:  putstatic   #8; //storing it to a static variable
5:  getstatic   #8; //loading "dev" from a static variable
8:  astore_0        //storing "dev" to a temp variable
9:  ldc #9;         //loading String "override variable s"
11: putstatic   #8; //setting a static variable
14: aload_0         //loading a temp avariable
15: areturn         //returning it
16: astore_1
17: ldc #9;         //loading String "override variable s"
19: putstatic   #8; //setting a static variable
22: aload_1
23: athrow

java mempertahankan string "dev" agar tidak diubah sebelum kembali. Bahkan di sini akhirnya tidak ada blok sama sekali.

Ada 2 hal yang patut diperhatikan di sini:

• String tidak berubah. Saat Anda mengatur s ke "override variable s", Anda mengatur s untuk merujuk ke String yang digarisbawahi, tidak mengubah buffer char yang melekat pada objek s untuk mengubah ke "override variable s".
• Anda menaruh referensi ke s pada tumpukan untuk kembali ke kode panggilan. Setelah itu (ketika blok akhirnya berjalan), mengubah referensi seharusnya tidak melakukan apa pun untuk nilai pengembalian yang sudah ada di stack.

Saya sedikit mengubah kode Anda untuk membuktikan maksud Ted.

Seperti yang Anda lihat di output smemang berubah tetapi setelah pengembalian.

public class Test {

public String s;

public String foo() {

    try {
        s = "dev";
        return s;
    } finally {
        s = "override variable s";
        System.out.println("Entry in finally Block");

    }
}

public static void main(String[] xyz) {
    Test obj = new Test();
    System.out.println(obj.foo());
    System.out.println(obj.s);
}
}

Keluaran:

Entry in finally Block 
dev 
override variable s

Secara teknis, returnblok uji coba tidak akan diabaikan jika finallyblok ditentukan, hanya jika blok akhirnya juga menyertakan a return.

Ini adalah keputusan desain yang meragukan yang mungkin merupakan kesalahan dalam retrospeksi (seperti referensi yang dapat dibatalkan / dapat diubah secara default, dan, menurut beberapa, mengecek pengecualian). Dalam banyak hal perilaku ini persis konsisten dengan pemahaman sehari-hari tentang apa finallyartinya - "tidak peduli apa yang terjadi sebelumnya di tryblok, selalu jalankan kode ini." Karenanya, jika Anda mengembalikan true dari finallyblok, efek keseluruhan harus selalu ke return s, bukan?

Secara umum, ini jarang idiom yang baik, dan Anda harus menggunakan finallyblok secara bebas untuk membersihkan / menutup sumber daya tetapi jarang jika pernah mengembalikan nilai dari mereka.

Coba ini: Jika Anda ingin mencetak nilai ganti s.

finally {
    s = "override variable s";    
    System.out.println("Entry in finally Block");
    return s;
}