สุดท้าย: ปิดใช้งานสวิตช์ polymorphic ~
ปรับเปลี่ยนตัวแปร: ตัวแปรไม่สามารถเปลี่ยนแปลงได้
แก้ไขคลาส: คลาสไม่สามารถสืบทอดได้
วิธีการแก้ไข: วิธีการไม่สามารถเขียนใหม่ได้
สุดท้าย: บล็อกคำสั่งสุดท้ายที่ใช้ในการประมวลผลข้อยกเว้น
ไม่ว่าจะมีข้อยกเว้นหรือไม่ก็ตามจะต้องดำเนินการ ~~~
รหัส Java
คลาสสุดท้ายของสาธารณะในที่สุด {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ลอง {โยน nullpointerexception ใหม่ (); } catch (nullpointerexception e) {system.out.println ("โปรแกรมโยนข้อยกเว้น"); } ในที่สุด {system.out.println ("บล็อกคำสั่งสุดท้ายถูกดำเนินการ"); -การใช้คำหลักในที่สุดใน Java
เมื่อเปรียบเทียบกับโมเดลภาษาอื่น ๆ คำหลักในที่สุดก็เป็นส่วนเสริมที่ดีที่สุดในรูปแบบการจัดการ Java Exception โครงสร้างในที่สุดอนุญาตให้รหัสดำเนินการเสมอโดยไม่คำนึงว่าข้อยกเว้นเกิดขึ้นหรือไม่ ใช้ในที่สุดเพื่อรักษาสถานะภายในของวัตถุและเพื่อทำความสะอาดทรัพยากรที่ไม่ใช่หน่วยความจำ ในที่สุดหากไม่มีรหัสของคุณจะสับสน ตัวอย่างเช่นรหัสต่อไปนี้แสดงให้เห็นว่าคุณต้องเขียนโค้ดไปยังทรัพยากรที่ไม่ใช่หน่วยความจำฟรีโดยไม่ต้องใช้ในที่สุด:
นำเข้า Java.net.*; นำเข้า java.io.*; คลาสที่ไม่มี finally {public void foo () พ่น ioexception {// สร้างซ็อกเก็ตบนพอร์ตฟรี serversocket ss = ใหม่ serversocket (0); ลอง {ซ็อกเก็ตซ็อกเก็ต = ss.accept (); // รหัสอื่น ๆ ที่นี่ ... } catch (ioexception e) {ss.close (); // 1 โยน e; } // ... ss.close (); // 2}}รหัสนี้สร้างซ็อกเก็ตและเรียกวิธีการยอมรับ ก่อนที่จะออกจากวิธีการคุณต้องปิดซ็อกเก็ตนี้เพื่อหลีกเลี่ยงช่องโหว่ของทรัพยากร เพื่อให้งานนี้สำเร็จเราเรียกปิดที่ // 2 ซึ่งเป็นคำสั่งสุดท้ายของวิธีการ แต่จะเกิดอะไรขึ้นถ้ามีข้อยกเว้นเกิดขึ้นในบล็อกลอง? ในกรณีนี้การโทรปิดที่ // 2 ไม่เคยเกิดขึ้น ดังนั้นคุณต้องจับข้อยกเว้นนี้และแทรกการโทรอื่นเพื่อปิดที่ // 1 ก่อนที่จะออกใหม่ข้อยกเว้นนี้ใหม่ สิ่งนี้ทำให้มั่นใจได้ว่าซ็อกเก็ตจะถูกปิดก่อนที่จะออกจากวิธีการ
การเขียนโค้ดเช่นนี้เป็นทั้งความยุ่งยากและผิดพลาดได้ง่าย แต่มันก็เป็นสิ่งจำเป็นหากไม่มีในที่สุด น่าเสียดายที่ในภาษาที่ไม่มีกลไกในที่สุดโปรแกรมเมอร์อาจลืมจัดระเบียบรหัสด้วยวิธีนี้ส่งผลให้เกิดช่องโหว่ของทรัพยากร ประโยคในที่สุดใน Java แก้ปัญหานี้ ในที่สุดรหัสก่อนหน้านี้สามารถเขียนลงในแบบฟอร์มต่อไปนี้:
นำเข้า Java.net.*; นำเข้า java.io.*; คลาสที่มี finally {public void foo2 () พ่น ioexception {// สร้างซ็อกเก็ตบนพอร์ตฟรี serversocket ss = serversocket ใหม่ (0); ลอง {ซ็อกเก็ตซ็อกเก็ต = ss.accept (); // รหัสอื่น ๆ ที่นี่ ... } ในที่สุด {ss.close (); -บล็อกในที่สุดทำให้มั่นใจได้ว่าวิธีการปิดจะถูกดำเนินการเสมอโดยไม่คำนึงถึงว่ามีการออกข้อยกเว้นภายในบล็อกลองหรือไม่ ดังนั้นจึงมั่นใจได้ว่าวิธีการปิดจะถูกเรียกเสมอก่อนที่จะออกจากวิธีการ วิธีนี้คุณสามารถมั่นใจได้ว่าซ็อกเก็ตถูกปิดและคุณไม่ได้รั่วไหลออกมา ไม่จำเป็นต้องมีการจับบล็อกอื่นในวิธีนี้ Catch Block มีให้ในตัวอย่างแรกเพียงเพื่อปิดซ็อกเก็ตตอนนี้ปิดตัวลงในที่สุด หากคุณจัดเตรียมบล็อกการจับรหัสในบล็อกในที่สุดจะถูกเรียกใช้งานหลังจากที่บล็อกจับเสร็จแล้ว
ในที่สุดบล็อกจะต้องใช้กับการลองหรือลอง/จับบล็อก นอกจากนี้ยังเป็นไปไม่ได้ที่จะออกจากบล็อกลองโดยไม่ต้องดำเนินการบล็อกในที่สุด หากบล็อกในที่สุดมีอยู่มันจะดำเนินการเสมอ (คำสั่งนี้ถูกต้องจากมุมมองนั้นมีวิธีออกจากบล็อกลองโดยไม่ดำเนินการบล็อกในที่สุดหากรหัสดำเนินการ System.Exit (0); คำสั่งภายในการลองแอปพลิเคชันจะสิ้นสุดลงโดยไม่ดำเนินการในที่สุด