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

ความหมายสุดท้าย

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

ตัวแปรใด ๆ หรือตัวแปรท้องถิ่น (ในวิธีการหรือบล็อกรหัสเรียกว่าตัวแปรท้องถิ่น) การประกาศสำหรับตัวแปรสมาชิกหรือตัวแปรท้องถิ่น ต่อไปนี้เป็นตัวอย่างของตัวแปร modifier สุดท้าย:

 intvalue สุดท้าย = 1;

จุดเสริม:

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

วิธีสุดท้าย

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

 บุคคลชั้นเรียนสาธารณะ {public final void printname () {system.out.println ("wangzhengyi");}}}

ชั้นสุดท้าย

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

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

• ประกาศชั้นเรียนเป็นรอบชิงชนะเลิศเพื่อให้ไม่สามารถสืบทอดได้
• สมาชิกทุกคนประกาศว่าเป็นส่วนตัวเพื่อให้สมาชิกเหล่านี้ไม่ได้รับอนุญาตโดยตรง
• อย่าให้วิธีการตั้งค่าสำหรับตัวแปร
• ระบุสมาชิกตัวแปรทั้งหมดไปสู่ตำแหน่งสุดท้ายเพื่อให้พวกเขาสามารถกำหนดได้เพียงครั้งเดียว
• เริ่มต้นสมาชิกทั้งหมดด้วยตัวสร้างและสำเนาลึก
• ในวิธีการ getter อย่ากลับไปที่วัตถุโดยตรง แต่สำเนาของวัตถุโคลนนิ่งและกลับไปที่วัตถุ

หมายเหตุ: ความแตกต่างระหว่างสำเนาตื้นและสำเนาลึก:

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

ตัวอย่างที่ไม่น่าเชื่อถือ:

 นำเข้า java.util.hashmap; นำเข้า java.util.itrator; String getName () {return name;} / *** วัตถุตัวแปร: สำเนาของวัตถุส่งคืน* @return* / public hashmap <จำนวนเต็ม, string> gethmap () {rashmap <จำนวนเต็ม, st. );} / *** คอนสตรัคเตอร์ของการคัดลอกลึก* / สาธารณะ finalclassexample (int id, ชื่อสตริง, hashmap <จำนวนเต็ม, สตริง> แผนที่) {this.id = id; TMAP = ใหม่ HashMap <จำนวนเต็ม, String> (); , map.get (key));} this.hmap = tmap;} /*** การใช้งานสำเนาตื้น* / /* finalClassExample สาธารณะ (ID int, ชื่อสตริง, hashmap <intt eger, สตริง> แผนที่) {สิ่งนี้ .id = id;

ผลประโยชน์คำหลักสุดท้าย

ข้อดีของการใช้คำหลักสุดท้ายมีดังนี้:

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