Mari Berbincang Tentang Kata Kunci Akhir Dalam Java

Java mempunyai kata kunci ini — muktamad. Ia boleh digunakan untuk kelas, kaedah, pembolehubah (termasuk parameter kaedah). Untuk kelas, kata kunci akhir bermakna kelas tidak boleh mempunyai subkelas, iaitu warisan adalah dilarang... Ini berguna apabila mencipta objek yang tidak boleh diubah (tidak boleh diubah). Sebagai contoh, kelas String diisytiharkan sebagai muktamad.

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

Saya juga harus ambil perhatian bahawa pengubah suai akhir tidak boleh digunakan pada kelas abstrak (yang mempunyai kata kunci abstrak), kerana ini adalah konsep yang saling eksklusif. Untuk kaedah terakhir, pengubah suai bermaksud kaedah itu tidak boleh ditindih dalam subkelas. Ini berguna apabila kita ingin menghalang pengubahan pelaksanaan asal.

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

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

Untuk pembolehubah jenis primitif, kata kunci akhir bermakna bahawa nilai, setelah ditetapkan, tidak boleh diubah. Untuk pembolehubah rujukan, ini bermakna selepas objek ditetapkan, anda tidak boleh menukar rujukan kepada objek itu. Ini sangat penting! Rujukan tidak boleh diubah, tetapi keadaan objek boleh diubah. Java 8 memperkenalkan konsep baharu: muktamad berkesan. Ia hanya terpakai kepada pembolehubah (termasuk parameter kaedah). Intinya ialah walaupun ketiadaan jelas kata kunci akhir, nilai pembolehubah tidak berubah selepas permulaan. Dalam erti kata lain, kata kunci akhir boleh digunakan pada pembolehubah sedemikian tanpa ralat penyusunan. Pembolehubah akhir yang berkesan boleh digunakan dalam kelas tempatan (kelas dalaman tempatan), kelas tanpa nama (kelas dalaman tanpa nama) dan strim (API Aliran).

        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
        }

Sekarang, mari kita temuduga sedikit. Lagipun, matlamat untuk melengkapkan kursus CodeGym adalah untuk menjadi pembangun Java dan mencari pekerjaan yang menarik dan bergaji tinggi. Jadi, mari kita mulakan.

1. Apa yang boleh kita katakan tentang tatasusunan yang diisytiharkan muktamad?

2. Kita tahu bahawa kelas String tidak boleh diubah: kelas diisytiharkan muktamad. Nilai rentetan disimpan dalam tatasusunan aksara yang ditandakan dengan kata kunci akhir.

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

Bolehkah kita menggantikan nilai objek String (tanpa mengubah rujukan kepada objek)? Ini adalah soalan wawancara sebenar. Dan amalan menunjukkan bahawa ramai calon tidak menjawabnya dengan betul. Memahami cara kata kunci akhir digunakan, terutamanya untuk pembolehubah rujukan, adalah sangat penting. Semasa anda memikirkan perkara ini, saya akan membuat permintaan kecil kepada pasukan CodeGym. Sila berikan editor teks keupayaan untuk menambah blok yang kandungannya boleh ditunjukkan/disembunyikan apabila anda mengklik padanya. Jawapan:

1. Tatasusunan ialah objek, jadi kata kunci terakhir bermaksud bahawa sebaik sahaja rujukan kepada tatasusunan diberikan, rujukan itu tidak boleh diubah. Yang berkata, anda boleh menukar keadaan objek.

   
           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. Ya kita boleh. Perkara utama ialah memahami maksud kata kunci akhir yang berduri apabila digunakan dengan objek. API Refleksi boleh digunakan untuk menggantikan nilai.

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
         */
    }
}

Sila ambil perhatian bahawa jika kami telah cuba menukar pembolehubah akhir jenis primitif dengan cara ini, maka tiada apa yang akan berlaku. Saya cadangkan anda meyakinkan diri sendiri: buat kelas Java, sebagai contoh, dengan medan int akhir dan cuba ubah nilainya menggunakan API Refleksi. Semoga berjaya kepada semua!