Pag-usapan Natin ang Panghuling Keyword Sa Java

Ang Java ay may ganitong keyword — pangwakas. Maaari itong ilapat sa mga klase, pamamaraan, variable (kabilang ang mga parameter ng pamamaraan). Para sa isang klase, ang panghuling keyword ay nangangahulugan na ang klase ay hindi maaaring magkaroon ng mga subclass, ibig sabihin, ang pamana ay ipinagbabawal... Ito ay kapaki-pakinabang kapag lumilikha ng hindi nababago (hindi nababago) na mga bagay. Halimbawa, ang klase ng String ay idineklara bilang pangwakas.

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

Dapat ko ring tandaan na ang panghuling modifier ay hindi maaaring ilapat sa mga abstract na klase (mga may keyword na abstract), dahil ang mga ito ay kapwa eksklusibong mga konsepto. Para sa isang panghuling pamamaraan, ang modifier ay nangangahulugan na ang pamamaraan ay hindi maaaring ma-override sa mga subclass. Ito ay kapaki-pakinabang kapag gusto nating pigilan ang pagbabago ng orihinal na pagpapatupad.

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

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

Para sa mga variable ng primitive na uri, ang panghuling keyword ay nangangahulugan na ang halaga, kapag naitalaga na, ay hindi na mababago. Para sa mga reference na variable, nangangahulugan ito na pagkatapos maitalaga ang isang object, hindi mo mababago ang reference sa object na iyon. Ito ay mahalaga! Hindi mababago ang reference, ngunit maaaring baguhin ang estado ng object. Ipinakilala ng Java 8 ang isang bagong konsepto: epektibong pangwakas. Nalalapat lamang ito sa mga variable (kabilang ang mga parameter ng pamamaraan). Ang bottom line ay na sa kabila ng malinaw na kawalan ng panghuling keyword, ang halaga ng variable ay hindi nagbabago pagkatapos ng pagsisimula. Sa madaling salita, maaaring ilapat ang panghuling keyword sa naturang variable nang walang error sa compilation. Mabisang magagamit ang mga huling variable sa loob ng mga lokal na klase (mga lokal na panloob na klase), mga hindi kilalang klase (mga hindi kilalang panloob na klase), at mga stream (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
        }

Ngayon, magkaroon tayo ng kaunting panayam. Pagkatapos ng lahat, ang layunin ng pagkumpleto ng kursong CodeGym ay maging isang developer ng Java at makahanap ng isang kawili-wili at mahusay na bayad na trabaho. Kaya, magsimula tayo.

1. Ano ang masasabi natin tungkol sa isang array na idineklara na pangwakas?

2. Alam namin na ang String class ay hindi nababago: ang klase ay idineklara na pinal. Ang isang string na halaga ay nakaimbak sa isang char array na minarkahan ng pangwakas na keyword.

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

Maaari ba nating palitan ang halaga ng isang String object (nang hindi binabago ang reference sa object)? Ito ay mga totoong tanong sa panayam. At ipinapakita ng pagsasanay na maraming kandidato ang hindi sumasagot sa kanila ng tama. Ang pag-unawa sa kung paano ginagamit ang panghuling keyword, lalo na para sa mga reference na variable, ay napakahalaga. Habang pinag-iisipan mo ito, gagawa ako ng isang maliit na kahilingan sa koponan ng CodeGym. Mangyaring bigyan ang text editor ng kakayahang magdagdag ng isang bloke na ang nilalaman ay maaaring ipakita/itago kapag nag-click ka dito. Mga sagot:

1. Ang array ay isang object, kaya ang panghuling keyword ay nangangahulugan na kapag ang isang reference sa array ay naitalaga, ang reference ay hindi na mababago. Iyon ay sinabi, maaari mong baguhin ang estado ng bagay.

   
           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. Oo kaya natin. Ang pangunahing bagay ay upang maunawaan kung ano ang ibig sabihin ng matinik na panghuling keyword kapag ginamit sa mga bagay. Maaaring gamitin ang Reflection API para palitan ang mga value.

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

Pakitandaan na kung sinubukan naming baguhin ang panghuling variable ng isang primitive na uri sa ganitong paraan, walang nangyari. Iminumungkahi ko na kumbinsihin mo ang iyong sarili: lumikha ng isang Java class, halimbawa, na may panghuling int field at subukang baguhin ang halaga nito gamit ang Reflection API. Sana swertihin ang lahat!