คำอธิบายโดยละเอียดเกี่ยวกับวิธีการใช้คำหลักสุดท้ายในการเขียนโปรแกรมเชิงวัตถุใน Java

ใน Java คำหลักสุดท้ายใช้เพื่อประกาศว่าวัตถุนั้นไม่เปลี่ยนรูป วัตถุที่นี่รวมถึงตัวแปรวิธีการและคลาสซึ่งคล้ายกับคำหลัก const ใน C ++
วิธีการไม่เปลี่ยนแปลงที่ไม่สามารถเปลี่ยนแปลงได้ว่าหลังจากวัตถุถูกสร้างขึ้นสถานะจะไม่สามารถเปลี่ยนแปลงได้ คุณสามารถพิจารณาใช้คำหลักสุดท้ายจากสามมุมมอง:

• รหัสตัวเอง: ไม่ต้องการความหมายของวัตถุที่อธิบายโดยสุดท้ายที่จะเปลี่ยนแปลง
• ความปลอดภัย: วัตถุสุดท้ายมีคุณลักษณะแบบอ่านอย่างเดียวและเป็นเธรดที่ปลอดภัย
• ประสิทธิภาพ: วัตถุสุดท้ายนั้นไม่สามารถแก้ไขได้และการดำเนินการอ้างอิงนั้นมีประสิทธิภาพมากขึ้น

ตัวแปรสุดท้าย
กำหนดวัตถุสุดท้าย A จากนั้น A สามารถเริ่มต้นได้เพียงครั้งเดียว เมื่อเริ่มต้นข้อมูลของ A ไม่สามารถแก้ไขได้ หาก A เป็นประเภทการอ้างอิงวัตถุอื่น ๆ จะไม่สามารถรีเบิลได้
ตัวแปรสุดท้ายที่ไม่ได้เริ่มต้นเรียกว่าว่างรอบสุดท้าย หากเป็นตัวแปรสมาชิกจะต้องเริ่มต้นหรือกำหนดในตัวสร้าง
ตัวอย่าง:

 วงกลมชั้นเรียน {คงสุดท้าย double pi = 3.1415926; รัศมี int สุดท้าย = 5; int xpos สุดท้าย; int สุดท้าย ypos; วงกลมสาธารณะ (int x, int y) {xpos = x; ypos = y; -

วิธีสุดท้าย
หากคุณกำหนดวิธีสุดท้ายวิธีการไม่สามารถโหลดได้ ผู้ออกแบบวิธีการไม่ต้องการให้ฟังก์ชั่นอื่น ๆ ที่เกี่ยวข้องเกิดขึ้นเนื่องจากการโอเวอร์โหลดวิธีการ
ตัวอย่าง:

 คลาส baseclass {วิธีโมฆะสุดท้ายสาธารณะ () {}} คลาส DerivedClass ขยาย baseclass {วิธีโมฆะสุดท้ายสาธารณะ () {} // ข้อผิดพลาดการรวบรวม}

ควรสังเกตว่าคำจำกัดความของวิธีสุดท้ายอาจไม่จำเป็นต้องสร้างผลกระทบของอินไลน์เพราะวิธีการไม่ขึ้นอยู่กับกลยุทธ์ของ JVM แทนที่จะเป็นคำหลักสุดท้ายหรือไม่มันไม่ถูกต้องในการปรับปรุงประสิทธิภาพของวิธีการผ่านการออกแบบขั้นสุดท้าย

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

การคัดลอกรหัสมีดังนี้:
สตริงสุดท้ายของคลาสสาธารณะขยายวัตถุใช้งาน serializable, เทียบเคียงได้ <string>, charsequence

• หลังจากอินสแตนซ์ของคลาสสตริงเริ่มต้นเนื้อหาของมันจะไม่สามารถเปลี่ยนแปลงได้ วิธีการใด ๆ ที่จัดทำโดยคลาสสตริงเพื่อแก้ไขวัตถุสตริงสามารถสร้างวัตถุสตริงใหม่เท่านั้นซึ่งจะทำให้การทำงานของสตริงง่ายขึ้นอย่างมากและทำให้รหัสง่ายต่อการอ่านและทำความเข้าใจ
• String Final เป็นเงื่อนไขที่จำเป็นสำหรับการใช้การแทรกแซงสตริง (มีเพียงหนึ่งสำเนาของค่าสตริงที่แตกต่างกันในหน่วยความจำ) เนื่องจากโดยปกติจะมีวัตถุสตริงจำนวนมากในรหัสและการอ้างอิงที่แตกต่างกันจะชี้ไปที่พื้นที่สตริงเดียวกัน หากสตริงไม่สิ้นสุดเมื่อเนื้อหาของพื้นที่สตริงเปลี่ยนแปลงการอ้างอิงทั้งหมดจำเป็นต้องรู้สถานการณ์นี้ การใช้กลไกนี้มีความซับซ้อนมากและจะส่งผลกระทบอย่างไม่ต้องสงสัย การแทรกแซงของสตริงสามารถบันทึกพื้นที่หน่วยความจำและประหยัดเวลาและค่าใช้จ่าย;
• สตริงเป็นแบบอ่านอย่างเดียวดังนั้นจึงไม่จำเป็นต้องกังวลเกี่ยวกับเนื้อหาที่สำคัญมากที่ถูกดัดแปลง

ชั้นเรียนภายในและสุดท้าย
เมื่อกำหนดคลาสภายในที่ไม่ระบุชื่อในวิธีการคลาสด้านในสามารถเข้าถึงตัวแปรประเภทสุดท้ายในวิธีการเพื่อให้คอมไพเลอร์ Java สามารถจับค่าของตัวแปรล่วงหน้าและบันทึกสำเนาในคลาสภายใน เมื่อวิธีการถูกทำลายพื้นที่หน่วยความจำของคลาสด้านในยังคงเสร็จสมบูรณ์
ตัวอย่าง:

 wrapper คลาสสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// object obj = null; // รวบรวมข้อผิดพลาดวัตถุสุดท้าย obj = null; เธรดใหม่ (ใหม่ runnable () {public void run () {obj = "hello";}}). start (); -

PS: ปัญหาที่คลาสที่ไม่ระบุชื่อภายในไม่สามารถเข้าถึงตัวแปรที่ไม่ใช่รอบรองชนะเลิศภายนอกได้
ฟังดูเป็นเรื่องยากที่จะพูดถึง แต่ที่จริงแล้วฉันต้องการพูดคุยเพิ่มเติมเกี่ยวกับคุณสมบัติบางอย่างของชั้นเรียนภายใน Java

เหตุผลที่ฉันนึกถึงคำถามนี้คือเมื่อฉันอ่านรหัสเกี่ยวกับ HTTP KEDALIVE ในซอร์สโค้ด JDK เมื่อเร็ว ๆ นี้หนึ่งในไฟล์ต้นฉบับ Sun.net.www.protocol.http.httpurlconnection.java โดยบังเอิญเห็นรหัสต่อไปนี้

 ผลลัพธ์บูลีนสุดท้าย [] = {false}; java.security.accessController.doprivileged (java.security.privilegedAction () {วัตถุสาธารณะ Run () {ลอง {inetaddress a1 = inetaddress.getByName (h1); a1.equals (a2);} catch (UnknownHostExcept

คลาสภายในที่ไม่ระบุชื่อของ Java ไม่สามารถเข้าถึงตัวแปรที่ไม่ใช่รอบรองชนะเลิศของฟังก์ชั่นที่สอดคล้องกันได้ ในการเข้าถึงตัวแปรท้องถิ่นภายนอกตัวแปรนี้จะต้องกำหนดเป็น fianl ก่อน อย่างไรก็ตามเมื่อมันถูกกำหนดให้เป็นขั้นสุดท้ายค่าของตัวแปรนี้ไม่สามารถแก้ไขได้ในคลาสภายในที่ไม่ระบุชื่อดังนั้นจึงไม่ใช่เรื่องง่ายที่จะส่งคืนค่าที่เป็นประโยชน์บางอย่างในคลาสภายในที่ไม่ระบุชื่อ รหัสนี้ใช้วิธีที่ฉลาดมากโดยใช้อาร์เรย์ที่นี่เพื่อข้ามข้อ จำกัด นี้ แม้ว่าเราจะไม่สามารถแก้ไขการอ้างอิงไปยังผลลัพธ์ตัวแปร แต่เราสามารถแก้ไขเนื้อหาของอาร์เรย์ที่ชี้ไปที่ผลลัพธ์

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

ก่อนที่จะดำเนินการต่อบทความนี้ฉันรู้สึกว่าจำเป็นอย่างยิ่งที่จะต้องชี้แจงคำศัพท์ Java บางส่วนที่เกี่ยวข้องในบทความนี้ คำเหล่านี้ไม่ใช่เรื่องง่ายที่จะแปลเป็นภาษาจีนดังนั้นเราจะยังคงอธิบายเป็นภาษาอังกฤษ

 // นี่คือ ClassPublic Class Javaterm {// ฟิลด์หรือฟิลด์ตัวแปรสมาชิกส่วนตัว // constructor สาธารณะ javaterm () {} // วิธีการโมฆะสาธารณะวิธี () {// ตัวแปรท้องถิ่น int localVariable = 0; // คลาสท้องถิ่นคลาส LocalClass {Public LocalClass () {}} // คลาสที่ไม่ระบุชื่อใหม่ runnable () {public void run () {}}; -

วันนี้เราจะมุ่งเน้นไปที่ชั้นเรียนท้องถิ่นและชั้นเรียนที่ไม่ระบุชื่อซึ่งทั้งคู่อยู่ในชั้นเรียนชั้นใน

Java ช่วยให้เราสามารถกำหนดคลาสอื่นในชั้นเรียนที่เรียกว่าคลาสซ้อนกันและคลาสซ้อนกันสามารถแบ่งออกเป็นสองประเภทหนึ่งคือคลาสซ้อนกันคงที่และอีกคลาสที่ไม่คงที่หรือที่รู้จักกันในชื่อชั้นใน ชั้นเรียนชั้นในยังสามารถแบ่งออกเป็นชั้นเรียนท้องถิ่นและชั้นเรียนที่ไม่ระบุชื่อ

ข้อ จำกัด บางประการของชั้นเรียนที่ไม่ระบุชื่อ

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