Döndürülen değişkeni bir final bloğunda değiştirmek neden dönüş değerini değiştirmiyor?

Aşağıda gösterildiği gibi basit bir Java sınıfım var:

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

Ve bu kodun çıktısı şudur:

Entry in finally Block
dev  

Neden blokta sgeçersiz kılınmamış finally, ancak yine de basılı çıktıyı kontrol et?

tryYürütülmesi ile blok tamamlar returntablosu ve değerinin szaman returntablosu yürütür yöntemi tarafından döndürülen bir değerdir. Aslında finallyhükmü sonradan değerini değiştirir s(sonra returnifadesi tamamlanıncaya) dönüş değerini değiştirmek (bu noktada) değildir.

Yukarıdakilerin , referans veren nesneye değil s, finallybloktaki kendisinin değerindeki değişikliklerle silgilendiğini unutmayın. Eğer skesilebilir bir nesne için bir referans (ki Stringdeğildir) ve içeriği nesnenin değiştiğini finallyblok, daha sonra bu değişiklikler verilen değer görülebilir.

Tüm bunların nasıl çalıştığına dair ayrıntılı kurallar Java Dil Spesifikasyonu Bölüm 14.20.2'de bulunabilir . Bir returnifadenin yürütülmesinin trybloğun ani bir sonlandırılması olarak sayıldığına dikkat edin (" Try bloğunun yürütülmesi başka herhangi bir nedenle R .... ' nin yürütülmesi aniden tamamlanırsa " başlayan bölüm geçerlidir). Bir ifadenin neden bir bloğun aniden sonlandırılması olduğunu öğrenmek için JLS Bölüm 14.17'ye bakın return.

Daha ayrıntılı olarak: Bir ifadenin hem trybloğu hem de bloğu ifadeler nedeniyle aniden sona ererse, §14.20.2'deki aşağıdaki kurallar geçerlidir:finallytry-finallyreturn

tryBloğun yürütülmesi başka herhangi bir nedenle R [bir istisna atmanın yanı sıra] aniden tamamlanırsa, finallyblok yürütülür ve sonra bir seçim vardır:

• Eğer finallyblok ardından, normalde tamamlar trynedeni R. için deyim tamamlamalar aniden
• Eğer finallyblok nedeni S aniden tamamlar, sonra tryaniden nedeni S için deyim tamamlamalar (ve neden R atılır).

Sonuç, bloktaki ifadenin tüm ifadenin dönüş değerini belirlemesi returnve finallybloktan try-finallydöndürülen değerin tryatılmasıdır. Benzer bir şey meydana try-catch-finallyeğer deyimi tryblok, bir tarafından yakalanan bir özel durum atar catchbloğu ve her iki catchblok ve finallyblok var returnifadeleri.

Çünkü dönüş değeri, en sonunda çağrılmadan önce yığına konur.

Bayt kodunun içine bakarsak, JDK'nın önemli bir optimizasyon yaptığını ve foo () yönteminin şöyle göründüğünü göreceğiz :

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

Ve bayt kodu:

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 "dev" dizesini geri dönmeden önce değiştirilmekten korudu. Aslında burada nihayetinde engel yoktur.

Burada dikkate değer 2 şey var:

• Dizeler değişmezdir. S'yi "s değişkenlerini geçersiz kıl" olarak ayarladığınızda, s nesnesinin doğal karakter arabelleğini "değişken s geçersiz kıl" olarak değiştirmek için değil, satır içi dizeye başvuracak şekilde ayarlarsınız.
• Çağıran koda dönmek için yığındaki 'lere bir referans koyarsınız. Daha sonra (nihayet bloğu çalıştığında), referansı değiştirmek zaten yığında bulunan dönüş değeri için hiçbir şey yapmamalıdır.

Ted'in amacını kanıtlamak için kodunuzu biraz değiştiriyorum.

Gördüğünüz gibi çıktı sgerçekten değişiyor ama dönüşten sonra.

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

Çıktı:

Entry in finally Block 
dev 
override variable s

Teknik olarak konuşursak, returntry bloğundaki try bloğu, bir finallyblok tanımlanmışsa, yalnızca bu son blok ayrıca bir return.

Bu, muhtemelen geçmişe bakıldığında bir hata olan şüpheli bir tasarım kararıdır (referansların varsayılan olarak nullable / değiştirilebilir olması ve bazılarına göre kontrol edilen istisnalar gibi). Birçok yönden bu davranış, ne finallyanlama geldiğine dair günlük konuşma anlayışıyla tam olarak tutarlıdır - " tryblokta önceden ne olursa olsun , her zaman bu kodu çalıştırın." Bu nedenle, bir finallybloktan true döndürürseniz , genel etki her zaman olmalıdır return s, hayır?

Genel olarak, bu nadiren iyi bir deyimdir ve finallykaynakları temizlemek / kapatmak için blokları serbestçe kullanmalısınız, ancak nadiren onlardan bir değer döndürürseniz.

Şunu deneyin: s'nin geçersiz kılma değerini yazdırmak istiyorsanız.

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