คีย์เวิร์ด JAVA Final ใช้เพื่อแก้ไขข้อมูล วิธีการ หรือคลาส ซึ่งโดยทั่วไปหมายถึง "ไม่สามารถเปลี่ยนแปลงได้" กล่าวคือ ไม่สามารถเปลี่ยนแปลงข้อมูลได้ ไม่สามารถแทนที่วิธีการได้ และคลาสไม่สามารถสืบทอดได้ โดยทั่วไปมีเหตุผลสองประการในการใช้ขั้นตอนสุดท้าย: การออกแบบและประสิทธิภาพ เมื่อมีการอัปเดตเวอร์ชัน JAVA คอมไพลเลอร์และ JVM จะสามารถจัดการปัญหาด้านประสิทธิภาพบางอย่างได้ ดังนั้นการใช้ขั้นสุดท้ายในการแก้ปัญหาด้านประสิทธิภาพจึงไม่ใช่เรื่องสำคัญนัก
ตัวแก้ไขขั้นสุดท้ายส่วนใหญ่จะใช้ในฟิลด์ของประเภทข้อมูลดั้งเดิมหรือคลาสที่ไม่เปลี่ยนรูป (หากวิธีการทั้งหมดในคลาสไม่เปลี่ยนอ็อบเจ็กต์ คลาสนี้จะเป็นคลาสที่ไม่เปลี่ยนรูป String เป็นคลาสที่ไม่เปลี่ยนรูป)
【ข้อมูลสุดท้าย】
มีสองสถานการณ์หลักที่ใช้คำสำคัญ Final เพื่อแก้ไขข้อมูล:
1. ค่าคงที่เวลาคอมไพล์
2. ค่าเริ่มต้นเมื่อรันไทม์
สำหรับค่าคงที่เวลาคอมไพล์ จะอ้างถึงฟิลด์ที่เป็นทั้งค่าคงที่และค่าสุดท้าย (ตามแบบแผน ค่าคงที่เวลาคอมไพล์จะถูกตั้งชื่อด้วยตัวพิมพ์ใหญ่ทั้งหมด และแต่ละคำจะคั่นด้วยเครื่องหมายขีดล่าง) โดยจะใช้พื้นที่เก็บข้อมูลเท่านั้น ไม่สามารถเปลี่ยนแปลงได้ คอมไพเลอร์สามารถแทนที่ค่าคงที่เวลาคอมไพล์เป็นสูตรการคำนวณใดๆ ที่อาจใช้ กล่าวคือ สูตรการคำนวณสามารถดำเนินการได้ในเวลาคอมไพล์ ซึ่งช่วยลดภาระรันไทม์ได้ค่อนข้างมาก ค่าคงที่เวลาคอมไพล์จะต้องมีค่าที่กำหนดเมื่อถูกกำหนด (ไม่จำเป็นต้องเป็นประเภทพื้นฐาน)
สำหรับค่าที่เริ่มต้นขณะรันไทม์ สำหรับประเภทพื้นฐาน Final ทำให้ค่าไม่เปลี่ยนแปลง สำหรับการอ้างอิงวัตถุ Final ทำให้การอ้างอิงไม่เปลี่ยนแปลง กล่าวคือ ไม่สามารถเปลี่ยนให้ชี้ไปยังวัตถุอื่นได้ ( ใช้ได้กับอาร์เรย์ อาร์เรย์ก็เป็นวัตถุเช่นกัน)
TESTD สตริงสุดท้ายแบบคงที่ส่วนตัว = "ทดสอบ";
สาธารณะคงที่สุดท้าย String TESTE = "ทดสอบ";
สตริงสุดท้ายแบบคงที่สาธารณะ [] TESTF = {"1", "2"}; // ประเภทที่ไม่ใช่พื้นฐาน
สตริงสุดท้ายคงที่ส่วนตัว [] TESTG = สตริงใหม่ [2];
โมฆะคงที่สาธารณะ main (String args []) {
int testA สุดท้าย = 1;
สตริงสุดท้าย testB = "ทดสอบ";
int สุดท้าย [] testC = {1,1,2,};
System.out.println(testC[1]);
ทดสอบC[1] = 123;
System.out.println(testC[1]);
-
-
JAVA อนุญาตให้สร้างฟิลด์สุดท้ายที่ยังไม่ได้กำหนด แต่ฟิลด์สุดท้ายจะต้องถูกกำหนดตามคำจำกัดความของฟิลด์หรือในคอนสตรัคเตอร์แต่ละตัว (ตามจำนวนคอนสตรัคเตอร์ที่มีอยู่) เพื่อให้แน่ใจว่าฟิลด์นั้นจะถูกเตรียมใช้งานก่อนใช้งาน ด้วยวิธีนี้ สามารถใช้ Final ได้อย่างยืดหยุ่นมากขึ้น ในคลาสเดียวกัน สามารถกำหนดค่าที่แตกต่างกันให้กับอ็อบเจ็กต์ต่าง ๆ ในขณะที่ยังคงลักษณะที่ไม่เปลี่ยนรูปไว้ได้
javaBlankFinal สาธารณะ () {
ว่างเปล่า = 2011;
-
javaBlankFinal สาธารณะ (int temp) {
ว่างเปล่า = 2012;
-
javaBlankFinal สาธารณะ (สตริงชั่วคราว) {
ว่างเปล่า = 2014;
-
โมฆะคงที่สาธารณะ main (String args []) {
ใหม่ javaBlankFinal();
-
-
มีเหตุผลสองประการในการใช้วิธีการสุดท้าย: เหตุผลหนึ่งคือการล็อควิธีการเพื่อป้องกันไม่ให้เขียนทับวิธีการและให้แน่ใจว่าพฤติกรรมของวิธีการยังคงไม่เปลี่ยนแปลงในระหว่างการสืบทอด อีกประการหนึ่งคือการแปลงการเรียกวิธีการเป็นการเรียกแบบอินไลน์เพื่อลดต้นทุนของวิธีการ โทร อย่างไรก็ตาม ในเวอร์ชันล่าสุด JVM สามารถออปติไมซ์ตัวเองได้ ดังนั้นจึงไม่จำเป็นต้องใช้วิธีการขั้นสุดท้ายเพื่อจัดการกับปัญหาด้านประสิทธิภาพ
เกี่ยวกับวิธีการสุดท้าย มีอีกสิ่งหนึ่งที่ควรทราบ วิธีการส่วนตัวทั้งหมดในชั้นเรียนถูกกำหนดโดยนัยว่าเป็นวิธีการสุดท้าย (คุณสามารถเพิ่มการแก้ไขขั้นสุดท้ายได้ แต่ก็ไม่มีความหมาย) เมื่อคุณพยายามที่จะแทนที่วิธีการส่วนตัว คอมไพลเลอร์จะไม่รายงานข้อผิดพลาด แต่ในความเป็นจริงแล้ว คุณไม่ได้เขียนทับวิธีการ คุณเพียงแค่สร้างวิธีการใหม่ เนื่องจากคลาสภายนอกไม่สามารถเข้าถึงวิธีการส่วนตัวได้ แน่นอนว่าไม่สามารถแทนที่ได้
การใช้คำอธิบายประกอบ @Override สามารถป้องกันปัญหาข้างต้นได้ ดังแสดงในโปรแกรม:
โมฆะสุดท้ายส่วนตัว FinalFunctionB(){
System.out.println("finalFunctionB");
-
โมฆะสุดท้าย FinalFunctionC(){
System.out.println("finalFunctionC");
-
ฟังก์ชั่นเป็นโมฆะD(){}
-
การแทนที่คลาส FinalFunction ขยายฟังก์ชันสุดท้าย {
//@Override เพิ่มคำอธิบายประกอบ @Override เพื่อระบุว่าเป็นการแทนที่หรือไม่
โมฆะสาธารณะ FinalFunctionA(){
System.out.println("แทนที่ FinalFunctionA");
-
โมฆะสุดท้ายสาธารณะ FinalFunctionB(){
System.out.println("แทนที่ FinalFunctionB");
-
//final void FinalFunctionC(){} //ไม่สามารถแทนที่เมธอดสุดท้ายจาก FinalFunction ได้
@แทนที่
void functionD(){} //วิธีการแทนที่จริง
-
คลาสสาธารณะ javaFinalFunction ขยาย FinalFunction {
โมฆะคงที่สาธารณะ main (String args []) {
FinalFunction ff = ใหม่ FinalFunction();
//ff.finalFunctionA(); //ไม่สามารถเรียกเมธอดส่วนตัวได้
//ff.finalFunctionB();
overrideFinalFunction off = ใหม่ overrideFinalFunction();
off.finalFunctionA(); // วิธีการสาธารณะ
off.finalFunctionB();
-
-
โดยทั่วไปการใช้คลาสสุดท้ายนั้นมีวัตถุประสงค์เพื่อการออกแบบ ซึ่งไม่อนุญาตให้สืบทอดคลาสนั้น เพื่อให้แน่ใจว่าพฤติกรรมของชั้นเรียนจะไม่เปลี่ยนแปลง และอาจหลีกเลี่ยงความเสี่ยงด้านความปลอดภัยด้วย วิธีการทั้งหมดในคลาสสุดท้ายถูกกำหนดโดยปริยายว่าเป็นวิธีการขั้นสุดท้าย ดังนั้นจึงไม่สามารถแทนที่ได้ (เนื่องจากคลาสสุดท้ายห้ามมิให้มีการสืบทอด วิธีการในคลาสจึงไม่สามารถแทนที่ได้) ใน Java core API มีตัวอย่างมากมายของการใช้ขั้นสุดท้าย เช่น java.lang.String ระบุขั้นสุดท้ายสำหรับคลาส String เพื่อป้องกันการเขียนทับวิธีการเช่น length()
สำหรับฟิลด์สุดท้าย แม้ว่าคลาสจะถูกประกาศให้เป็นที่สิ้นสุด ฟิลด์ในคลาสจะไม่กลายเป็นฟิลด์สุดท้ายโดยอัตโนมัติ
คลาสสาธารณะ javaFinalClass{
โมฆะคงที่สาธารณะ main (String args []) {
FinalClass fc = ใหม่ FinalClass();
System.out.println(fc.testA);
เอฟซี.testA = 2012;
System.out.println(fc.testA);
-
-