Mik a primitív típusok versus referencia típusok a Javában?

Question

IT Interview Practice · Accepted Answer

A Javában két alapvető típuskategória van: **primitív típusok** (egyszerű értékek közvetlenül tárolva) és **referencia típusok** (objektumok, ahol a változó egy referenciát/mutatót tárol az objektumra). Nagyon eltérően viselkednek a memóriában, az értékadásban és az összehasonlításban. ## A 8 primitív típus ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` A primitív típusok az **igazi értéket** közvetlenül tárolják, rögzített méretűek, nem lehetnek `null`, és a stack-en helyezkednek el (lokális változóknál). Gyorsak és memória-hatékonyak. ## Referencia típusok — objektumok ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` A referencia változók egy **referenciát** (memóriacímet) tárolnak a heap-en tárolt objektumra — nem magát az objektumot. Lehetnek `null` értékűek. ## A kritikus különbség: értékadás és összehasonlítás ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` Ez egy nagy csapda: **a `==` objektumokon az azonosságot (ugyanaz az objektum?) hasonlítja össze, nem a tartalmat** — a tartalom összehasonlításához használja a `.equals()` metódust. ## Wrapper osztályok összekapcsolják a kettőt ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` Minden primitív típusnak van egy wrapper osztálya (`int`→`Integer`, stb.) ahhoz, hogy a primitív típusok ott használhatók legyenek, ahol objektumokra van szükség (kollekcióban, generikus típusok). ## Miért fontos A primitív versus referencia típus megkülönböztetés alapvető a Javában és sok szofisztikált hiba és viselkedés forrása: az értékadás másol az értékeket primitív típusokhoz, de megosztja a referenciákat az objektumoknál (így a megosztott objektum módosítása minden referenciát érint), és különösen az, hogy **a `==` az objektumokon az azonosságot hasonlítja** (klasszikus hiba — használja a `.equals()` a tartalomhoz). Ennek megértése az összehasonlítások helyességét, a metódus argumentumokat (az objektumok gyakorlatilag referencia-értékként adódnak át), a null-kezelést (csak referenciák lehetnek null), és a teljesítményt (a primitív típusok könnyebbek) befolyásolja. Ez alapvető tudás a helyes Java írásához.

A 8 primitív típus

Referencia típusok — objektumok

A kritikus különbség: értékadás és összehasonlítás

Wrapper osztályok összekapcsolják a kettőt

Miért fontos

Kapcsolódó kérdések