Što su primitivni tipovi nasuprot referentnim tipovima u Javi?

Question

Accepted Answer

Java ima dvije temeljne kategorije tipova: **primitivni tipovi** (jednostavne vrijednosti pohranjene izravno) i **referentni tipovi** (objekti, gdje varijabla sadrži referencu/pokazivač na objekt). Ponašavaju se vrlo različito u memoriji, dodjeli i usporedbi. ## 8 primitivnih tipova ```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 ``` Primitivni tipovi pohranjuju **stvarnu vrijednost** izravno, imaju fiksnu veličinu, ne mogu biti `null`, i nalaze se na stack-u (za lokalne varijable). Brzi su i memorijski učinkoviti. ## Referentni tipovi — objekti ```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 ``` Referentne varijable sadrže **referencu** (memorijsku adresu) na objekt pohranjen na heap-u — ne sam objekt. Mogu biti `null`. ## Kritična razlika: dodjela i usporedba ```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 ``` Ovo je velik problem: **`==` na objektima uspoređuje identitet (isti objekt?), ne sadržaj** — koristite `.equals()` za usporedbu sadržaja. ## Wrapper klase povezuju oba ```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 ``` Svaki primitivni tip ima wrapper klasu (`int`→`Integer`, itd.) tako da se primitivni tipovi mogu koristiti gdje su potrebni objekti (kolekcije, generički tipovi). ## Zašto je to važno Razlika između primitivnih i referentnih tipova je temeljna za Javu i izvor mnogih suptilnih grešaka i ponašanja: dodjela kopira vrijednosti za primitivne tipove, ali dijeli reference za objekte (pa izmjena dijeljenog objekta utječe na sve reference), a posebno što **`==` uspoređuje identitet za objekte** (klasična greška — koristite `.equals()` za sadržaj). Razumijevanje ovoga utječe na ispravnost usporedbi, argumenata metoda (objekti se učinkovito prosljeđuju po vrijednosti reference), rukovanja sa `null` vrijednostima (samo reference mogu biti `null`) i performansi (primitivni tipovi su lakši). To je temeljno znanje za pisanje ispravne Jave.