เหตุใดการเปลี่ยนแปลงตัวแปรที่ส่งคืนในบล็อกในที่สุดจึงไม่เปลี่ยนค่าส่งคืน

ฉันมีคลาส Java ง่ายๆดังที่แสดงด้านล่าง:

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

และผลลัพธ์ของรหัสนี้คือ:

Entry in finally Block
dev  

เหตุใดจึงsไม่ถูกแทนที่ในfinallyบล็อก แต่ยังควบคุมงานพิมพ์ที่พิมพ์ออกมา?

tryเสร็จสมบูรณ์บล็อกที่มีการดำเนินการของreturnคำสั่งและความคุ้มค่าของsในขณะที่returnคำสั่งดำเนินการเป็นค่าส่งกลับโดยวิธีการ ความจริงที่ว่าfinallyข้อในภายหลังเปลี่ยนค่าของs(หลังจากreturnคำสั่งเสร็จสมบูรณ์) ไม่ได้ (ณ จุดนั้น) เปลี่ยนค่าตอบแทน

โปรดทราบว่าข้อตกลงด้านบนเกี่ยวข้องกับการเปลี่ยนแปลงมูลค่าของsตัวเองในfinallyบล็อกไม่ใช่วัตถุที่sอ้างอิง หากsมีการอ้างอิงถึงวัตถุที่ไม่แน่นอน (ซึ่งStringไม่ใช่) และเนื้อหาของวัตถุถูกเปลี่ยนแปลงในfinallyบล็อกการเปลี่ยนแปลงเหล่านั้นจะถูกมองเห็นในค่าที่ส่งคืน

กฎรายละเอียดสำหรับวิธีการดำเนินการทั้งหมดนี้สามารถพบได้ในมาตรา 14.20.2 ของ Java Language ข้อกำหนด โปรดทราบว่าการประมวลผลreturnคำสั่งจะนับเป็นการยกเลิกtryบล็อกอย่างกะทันหัน(ส่วนที่เริ่มต้น " หากการดำเนินการบล็อกลองเสร็จสมบูรณ์ในทันทีด้วยเหตุผลอื่นใดก็ตาม R .... " ใช้) ดูส่วนที่ 14.17 ของ JLSเพราะเหตุใดreturnคำสั่งจึงสิ้นสุดการบล็อกโดยทันที

โดยรายละเอียดเพิ่มเติม: หากทั้งtryบล็อกและfinallyบล็อกของtry-finallyคำสั่งสิ้นสุดลงอย่างกะทันหันเนื่องจากreturnคำสั่งให้ใช้กฎต่อไปนี้ตั้งแต่ 14.20.2:

หากการดำเนินการtryบล็อกเสร็จสมบูรณ์ในทันทีด้วยเหตุผลอื่นใด R [นอกเหนือจากการโยนข้อยกเว้น] finallyบล็อกนั้นจะถูกดำเนินการและจากนั้นก็มีทางเลือก:

• หากfinallyบล็อกดำเนินการตามปกติtryคำสั่งจะเสร็จสมบูรณ์โดยทันทีด้วยเหตุผล R
• หากfinallyบล็อกเสร็จสมบูรณ์อย่างกะทันหันด้วยเหตุผล S tryคำสั่งนั้นจะเสร็จสมบูรณ์ทันทีสำหรับเหตุผล S (และเหตุผล R ถูกยกเลิก)

ผลลัพธ์คือreturnคำสั่งในfinallyบล็อกจะกำหนดค่าส่งคืนของtry-finallyคำสั่งทั้งหมดและค่าที่ส่งคืนจากtryบล็อกนั้นจะถูกยกเลิก สิ่งที่คล้ายกันเกิดขึ้นในtry-catch-finallyคำสั่งถ้าtryบล็อกส่งข้อยกเว้นมันถูกcatchบล็อกโดยบล็อกและทั้งcatchบล็อกและfinallyบล็อกมีreturnคำสั่ง

เพราะค่าส่งคืนจะถูกวางลงบนสแต็กก่อนที่จะโทรหา

ถ้าเราดูข้างใน bytecode เราจะสังเกตเห็นว่า JDK ทำการปรับให้เหมาะสมที่สำคัญและวิธีfoo ()ดูเหมือนว่า:

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

และ 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 เก็บรักษาสตริง "dev" จากการถูกเปลี่ยนก่อนที่จะส่งคืน ในความเป็นจริงที่นี่ไม่มีการปิดกั้นในที่สุด

มี 2 ​​สิ่งที่น่าสังเกตที่นี่:

• เงื่อนไขไม่เปลี่ยนรูป เมื่อคุณตั้งค่า s เป็น "override variable s" คุณได้ตั้งค่า s เพื่ออ้างถึง String แบบอินไลน์โดยไม่เปลี่ยนบัฟเฟอร์ char โดยธรรมชาติของวัตถุ s เพื่อเปลี่ยนเป็น "override variable s"
• คุณใส่การอ้างอิงถึง s บนสแต็คเพื่อกลับไปที่รหัสการโทร หลังจากนั้น (เมื่อบล็อกสุดท้ายรัน) การแก้ไขการอ้างอิงไม่ควรทำอะไรเลยสำหรับค่าส่งคืนที่มีอยู่แล้วในสแต็ก

ฉันเปลี่ยนรหัสของคุณเล็กน้อยเพื่อพิสูจน์จุดของเท็ด

อย่างที่คุณเห็นในเอาท์พุทsแน่นอนมีการเปลี่ยนแปลง แต่หลังจากกลับมา

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

เอาท์พุท:

Entry in finally Block 
dev 
override variable s

ในทางเทคนิคการพูดreturnในการลองบล็อกจะไม่ถูกเพิกเฉยหากมีการfinallyกำหนดบล็อกเฉพาะในที่สุดว่าบล็อกนั้นรวมถึงreturnบล็อกถูกกำหนดไว้เฉพาะในกรณีที่ในที่สุดก็ปิดกั้นนอกจากนี้ยังมี

เป็นการตัดสินใจออกแบบที่น่าสงสัยซึ่งอาจเป็นความผิดพลาดในการหวนกลับ (เหมือนการอ้างอิงที่เป็นโมฆะ / ไม่แน่นอนโดยค่าเริ่มต้นและตามข้อยกเว้นบางอย่างที่ตรวจสอบแล้ว) ในหลายวิธีพฤติกรรมนี้สอดคล้องกับความเข้าใจทางการพูดของสิ่งที่finallyหมายถึง - "ไม่ว่าจะเกิดอะไรขึ้นก่อนในtryบล็อกให้เรียกใช้รหัสนี้เสมอ" ดังนั้นหากคุณกลับมาจริงจากfinallyบล็อกผลกระทบโดยรวมจะต้องเป็นเสมอreturn sไม่ใช่หรือ

โดยทั่วไปนี่เป็นสำนวนที่ดีและคุณควรใช้finallyบล็อกอย่างอิสระสำหรับการล้าง / ปิดทรัพยากร แต่ไม่ค่อยมีคุณค่าถ้าพวกเขากลับมาจากพวกเขา

ลองสิ่งนี้: หากคุณต้องการพิมพ์ค่าแทนที่ของ s

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