Warum ändert das Ändern der zurückgegebenen Variablen in einem finally-Block nicht den Rückgabewert?

Ich habe eine einfache Java-Klasse wie unten gezeigt:

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

Und die Ausgabe dieses Codes ist folgende:

Entry in finally Block
dev  

Warum wird sim finallyBlock nicht überschrieben , aber die gedruckte Ausgabe gesteuert?

Der tryBlock wird mit der Ausführung der returnAnweisung abgeschlossen, und der Wert szum Zeitpunkt der returnAusführung der Anweisung ist der von der Methode zurückgegebene Wert. Die Tatsache, dass die finallyKlausel später den Wert von s(nach Abschluss der returnAnweisung) ändert, ändert (zu diesem Zeitpunkt) den Rückgabewert nicht.

Beachten Sie, dass sich das Obige auf Änderungen des Werts von sich sselbst im finallyBlock sbezieht , nicht auf das Objekt, auf das verwiesen wird. Wenn sein Verweis auf ein veränderbares Objekt (was Stringnicht der Fall ist) und der Inhalt des Objekts im finallyBlock geändert wurden , werden diese Änderungen im zurückgegebenen Wert angezeigt.

Die detaillierten Regeln für die Funktionsweise finden Sie in Abschnitt 14.20.2 der Java-Sprachspezifikation . Beachten Sie, dass die Ausführung einer returnAnweisung als abrupte Beendigung des tryBlocks gilt (es gilt der Abschnitt " Wenn die Ausführung des try-Blocks aus einem anderen Grund abrupt abgeschlossen wird ... "). In Abschnitt 14.17 des JLS erfahren Sie, warum eine returnAnweisung eine abrupte Beendigung eines Blocks darstellt.

Zur weiteren Detaillierung: Wenn sowohl der tryBlock als auch der finallyBlock einer try-finallyAnweisung aufgrund von returnAnweisungen abrupt beendet werden , gelten die folgenden Regeln aus §14.20.2:

Wenn die Ausführung des tryBlocks aus einem anderen Grund abrupt beendet wird [außer eine Ausnahme auszulösen], wird der finallyBlock ausgeführt, und dann gibt es eine Auswahl:

• Wenn der finallyBlock normal abgeschlossen wird, wird die tryAnweisung aus Grund R abrupt abgeschlossen.
• Wenn der finallyBlock aus Grund S abrupt abgeschlossen wird, wird die tryAnweisung aus Grund S abrupt abgeschlossen (und Grund R wird verworfen).

Das Ergebnis ist, dass die returnAnweisung im finallyBlock den Rückgabewert der gesamten try-finallyAnweisung bestimmt und der vom tryBlock zurückgegebene Wert verworfen wird. Ähnliches gilt für eine try-catch-finallyAnweisung, wenn der tryBlock eine Ausnahme auslöst, von einem catchBlock abgefangen wird und sowohl der catchBlock als auch der finallyBlock returnAnweisungen haben.

Weil der Rückgabewert vor dem Aufruf von finally auf den Stack gelegt wird.

Wenn wir uns den Bytecode ansehen, werden wir feststellen, dass JDK eine signifikante Optimierung vorgenommen hat und die foo () -Methode wie folgt aussieht:

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

Und 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 hat verhindert, dass der "dev" -String vor der Rückkehr geändert wird. Tatsächlich gibt es hier überhaupt keinen endgültigen Block.

Hier sind zwei Dinge bemerkenswert:

• Saiten sind unveränderlich. Wenn Sie s auf "Variable s überschreiben" setzen, setzen Sie s so, dass es sich auf den inline-String bezieht, ohne den inhärenten Zeichenpuffer des s-Objekts zu ändern, um in "Variable s überschreiben" zu ändern.
• Sie setzen einen Verweis auf das s auf dem Stapel, um zum aufrufenden Code zurückzukehren. Danach (wenn der finally-Block ausgeführt wird) sollte das Ändern der Referenz nichts für den Rückgabewert tun, der sich bereits auf dem Stapel befindet.

Ich ändere deinen Code ein wenig, um den Sinn von Ted zu beweisen.

Wie Sie in der Ausgabe sehen können, swird zwar geändert, aber nach der Rückkehr.

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

Ausgabe:

Entry in finally Block 
dev 
override variable s

Technisch gesehen wird der returnBlock im try-Block nicht ignoriert, wenn ein finallyBlock definiert ist, sondern nur, wenn dieser endgültige Block auch a enthält return.

Es ist eine zweifelhafte Entwurfsentscheidung, die im Nachhinein wahrscheinlich ein Fehler war (ähnlich wie Referenzen, die standardmäßig nullbar / veränderbar sind, und nach einigen überprüften Ausnahmen). In vielerlei Hinsicht stimmt dieses Verhalten genau mit dem umgangssprachlichen Verständnis dessen überein, was finallybedeutet: "Egal, was vorher im tryBlock passiert , führen Sie diesen Code immer aus." Wenn Sie also von einem finallyBlock true zurückgeben , muss der Gesamteffekt immer zu sein return s, nein?

Im Allgemeinen ist dies selten eine gute Redewendung, und Sie sollten finallyBlöcke großzügig zum Bereinigen / Schließen von Ressourcen verwenden, aber selten oder nie einen Wert von ihnen zurückgeben.

Versuchen Sie Folgendes: Wenn Sie den Überschreibungswert von s drucken möchten.

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