Mit jelentenek a static és final kulcsszavak?

Question

Accepted Answer

A **`static`** azt jelenti, hogy "az osztályhoz tartozik, nem az egyes objektumokhoz". A **`final`** azt jelenti, hogy "nem lehet megváltoztatni/kiterjeszteni". Ezek független kulcsszavak, amelyeket gyakran összekevernek, de különböző problémákat oldanak meg — és összekapcsolva konstansokat hoznak létre. ## static — osztály szintű, megosztott az összes objektum között ```java public class Counter { static int count = 0; // ONE shared variable for the whole class int id; // each instance has its OWN id Counter() { count++; // increments the shared counter id = count; } static void reset() { // static method — called on the class count = 0; } } Counter.count; // access via the CLASS name, no instance needed Counter.reset(); // call a static method on the class new Counter(); // each new instance shares `count` ``` A `static` tagok az osztályhoz tartoznak, nem az egyes objektumokhoz — egy másolat létezik, amelyet az összes objektum megosztva a osztály neve keresztül fér hozzá. A static metódusok nem használhatnak `this` vagy objektum mezőket (nem létezik objektum). ## final — nem lehet újrahozzárendelni / felülírni / kiterjeszteni ```java final int MAX = 100; // a constant — can't be reassigned MAX = 200; // ❌ compile error final class Util { } // a final CLASS can't be subclassed (e.g. String is final) class Base { final void critical() { } // a final METHOD can't be overridden } ``` A `final`-nak három használata van: egy final **változó** nem lehet újrahozzárendelve (konstans), egy final **metódus** nem lehet felülírva, és egy final **osztály** nem lehet kiterjesztve. ## Egy finom pont: final referenciák ```java final List list = new ArrayList<>(); list.add("a"); // ✅ ALLOWED — modifying the OBJECT, not the reference list = new ArrayList<>(); // ❌ ERROR — can't REASSIGN the reference ``` Egy `final` referenciánál a *referencia* nem lehet újrahozzárendelve, de az *objektum, amelyre mutat* még mindig módosítható — egy gyakori zavar pontja. ## Kombinálva: static final = konstans ```java public static final double PI = 3.14159; // class-level, unchangeable constant public static final String APP_NAME = "MyApp"; // convention: UPPER_SNAKE_CASE for static final constants ``` A `static final` együtt igazi konstansokat hoznak létre — egy megosztott, változhatatlan érték az egész osztályhoz, a konstansok definiálásának szokásos módja a Java-ban. ## Miért is fontos A `static` és a `final` alapvetően fontos Java kulcsszavak, amelyeknek különböző, fontos jelentésük van: a `static` lehetővé teszi az osztály szintű állapotot és segédmetódusokat (megosztott számlálók, gyárak, `Math.PI`, maga a `main` metódus), míg a `final` kényszeríti az immutabilitást és meggátolja az öröklődést/felülírást (konstansok, immutable osztályok, mint a String, kritikus metódusok lezárása). Az ezek megértése — beleértve a finom final-referencia viselkedést (referencia rögzített, objektum módosítható) és ezek konstansokká való kombinációját — elengedhetetlen az osztályok helyes tervezéséhez, konstansok megfelelő definiálásához, a bővíthetőség szabályozásához, valamint a megosztott és objektum-specifikus állapot érveléséhez. Ezek mindenhol jelen vannak a Java kódban és gyakori interjú témák.