พูดคุยเกี่ยวกับคำหลักสุดท้ายใน Java

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

    public final class String {
    }
    
    class SubString extends String { // Compilation error
    }

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

    public class SuperClass {
        public final void printReport() {
            System.out.println("Report");
        }
    }

    class SubClass extends SuperClass { 
        public void printReport() { //Compilation error
            System.out.println("MyReport");
        }
    }

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

        public void someMethod() {
            // In the example below, both a and b are effectively final, since they are assigned values only once:
            int a = 1;
            int b;
            if (a == 2) b = 3;
            else b = 4;
            // c is NOT effectively final since its value changes
            int c = 10;
            c++;
            
            Stream.of(1, 2).forEach(s-> System.out.println(s + a)); // OK
            Stream.of(1, 2).forEach(s-> System.out.println(s + c)); // Compilation error
        }

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

1. เราจะพูดอะไรเกี่ยวกับอาร์เรย์ที่ประกาศขั้นสุดท้ายได้บ้าง

2. เรารู้ว่าคลาส String นั้นเปลี่ยนรูปไม่ได้: คลาสนั้นถูกประกาศเป็นขั้นสุดท้าย ค่าสตริงถูกเก็บไว้ในอาร์เรย์ถ่านที่ทำเครื่องหมายด้วยคำหลักสุดท้าย

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

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

1. อาร์เรย์เป็นวัตถุ ดังนั้นคำหลักสุดท้ายหมายความว่าเมื่อกำหนดการอ้างอิงไปยังอาร์เรย์แล้ว การอ้างอิงนั้นจะไม่สามารถเปลี่ยนแปลงได้ ที่กล่าวว่า คุณสามารถเปลี่ยนสถานะของวัตถุ

   
           final int[] array = {1, 2, 3, 4, 5};
           array[0] = 9;	 // OK, because we're changing the contents of the array: {9, 2, 3, 4, 5}
           array = new int[5]; // Compilation error
   

2. ใช่เราทำได้ สิ่งสำคัญคือต้องเข้าใจว่าคำหลักสุดท้ายที่มีหนามหมายถึงอะไรเมื่อใช้กับอ็อบเจกต์ สามารถใช้ Reflection API เพื่อแทนที่ค่าต่างๆ

import java.lang.reflect.Field;

class B {
    public static void main(String[] args) throws Exception {
        String value = "Old value";
        System.out.println(value);

        // Get the String class's value field
        Field field = value.getClass().getDeclaredField("value");
        // Make it mutable
        field.setAccessible(true);
        // Set a new value
        field.set(value, "CodeGym".toCharArray());

        System.out.println(value);

        /* Output:
         * Old value
         * CodeGym
         */
    }
}

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