Beszéljünk a Java utolsó kulcsszójáról

A Java kulcsszóval rendelkezik – végleges. Alkalmazható osztályokra, metódusokra, változókra (beleértve a metódusparamétereket is). Egy osztálynál a végső kulcsszó azt jelenti, hogy az osztálynak nem lehetnek alosztályai, azaz tilos az öröklődés... Ez változtathatatlan (változhatatlan) objektumok létrehozásakor hasznos. Például a String osztály véglegesnek van nyilvánítva.

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

Azt is meg kell jegyeznem, hogy a végső módosító nem alkalmazható absztrakt osztályokra (azokra, amelyekre az abstract kulcsszó), mert ezek egymást kizáró fogalmak. Egy végső metódusnál a módosító azt jelenti, hogy a metódus nem bírálható felül az alosztályokban. Ez akkor hasznos, ha meg akarjuk akadályozni az eredeti megvalósítás megváltoztatását.

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

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

A primitív típusú változóknál a végső kulcsszó azt jelenti, hogy az érték a hozzárendelés után nem módosítható. A referenciaváltozók esetében ez azt jelenti, hogy az objektum hozzárendelése után nem módosíthatja az objektum hivatkozását. Ez fontos! A hivatkozás nem módosítható, de az objektum állapota módosítható. A Java 8 új koncepciót vezetett be: gyakorlatilag végleges. Csak a változókra vonatkozik (beleértve a metódusparamétereket is). A lényeg az, hogy a végső kulcsszó egyértelmű hiánya ellenére a változó értéke nem változik inicializálás után. Más szóval, a végső kulcsszó fordítási hiba nélkül alkalmazható egy ilyen változóra. A végső változók hatékonyan használhatók helyi osztályokon (helyi belső osztályok), névtelen osztályokon (anonim belső osztályok) és adatfolyamokon (Stream API) belül.

        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
        }

Most pedig legyen egy kis interjú. Hiszen a CodeGym tanfolyam elvégzésével az a cél, hogy Java fejlesztő legyél, és érdekes és jól fizető állást találj. Szóval, kezdjük.

1. Mit mondhatunk egy véglegesnek nyilvánított tömbről?

2. Tudjuk, hogy a String osztály megváltoztathatatlan: az osztályt véglegesnek nyilvánítják. A karakterlánc értéke egy char tömbben van tárolva, amelyet a final kulcsszóval jelölnek meg.

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

Lecserélhetjük egy String objektum értékét (az objektumra való hivatkozás megváltoztatása nélkül)? Ezek valódi interjúkérdések. A gyakorlat pedig azt mutatja, hogy sok jelölt nem válaszol rájuk helyesen. Nagyon fontos a végső kulcsszó használatának megértése, különösen a referenciaváltozók esetében. Miközben ezen gondolkodik, egy kis kéréssel fordulok a CodeGym csapatához. Kérjük, adjon lehetőséget a szövegszerkesztőnek egy olyan blokk hozzáadására, amelynek tartalma megjeleníthető/elrejthető, ha rákattint. Válaszok:

1. A tömb egy objektum, így a végső kulcsszó azt jelenti, hogy a tömbhöz való hivatkozás hozzárendelése után a hivatkozás nem módosítható. Ennek ellenére megváltoztathatja az objektum állapotát.

   
           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. Igen. A legfontosabb dolog az, hogy megértsük, mit jelent a tüskés végső kulcsszó, amikor tárgyakkal használjuk. A Reflection API használható értékek helyettesítésére.

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

Felhívjuk figyelmét, hogy ha egy primitív típus végső változóját próbáltuk volna így megváltoztatni, akkor semmi sem történt volna. Azt javaslom, győzze meg magát: hozzon létre például egy Java osztályt egy utolsó int mezővel, és próbálja meg megváltoztatni az értékét a Reflection API segítségével. Sok szerencsét mindenkinek!